Python Full-Stack
Web Development Guide

Python 3 is the current standard (Python 2 is completely deprecated). Core concepts: variables, data types (lists, dicts, tuples, sets), functions, classes (OOP — Object-Oriented Programming), file I/O, error handling (try/except), comprehensions (concise one-liner loops), generators, decorators, and context managers. Python 3.10+ introduced structural pattern matching (like a powerful switch/case). Current: Python 3.12/3.13. A résumé showing Python 2 only signals very outdated experience.

Every Python project uses pip and virtual environments — their absence is a red flag. pip installs packages from PyPI (Python Package Index — 500,000+ packages). Virtual environment tools: venv (built-in, simplest); Pipenv (combines pip + venv, adds Pipfile for reproducible installs); Poetry (modern, dependency resolution, publishing support — growing in popularity). requirements.txt files list all project dependencies for reproducible installations. Conda is used in data science environments.

Python's asyncio library and async/await syntax enable concurrent, non-blocking code — critical for modern web APIs. FastAPI is built entirely on async architecture. Django supports async views since Django 3.1. Key concepts: event loop, coroutines, awaitables, async context managers. Async Python is particularly important for I/O-bound operations (database queries, API calls, file reads) where blocking would waste CPU time. On a résumé, async/asyncio alongside FastAPI signals modern, performance-oriented back-end development.

Django is the most popular Python web framework for complete applications. Its "convention over configuration" approach means less decision-making for developers. Key features: Django ORM (database interaction in Python, not SQL); Django Admin (auto-generated admin interface — a massive productivity booster); Django Auth (complete user system out of the box); Django REST Framework (DRF) — the go-to extension for building APIs. Django 5+ (current) supports async views. Seeing "DRF" alongside Django on a résumé is very common for API-focused roles.

Flask is often described as a "microframework" — it starts minimal and grows as you add extensions (Flask-SQLAlchemy for databases, Flask-Login for auth, Flask-Mail for email, etc.). This flexibility is both a strength (you only include what you need) and a weakness (you make all the decisions). Flask is widely used for RESTful APIs, microservices, rapid prototyping, and data science/ML model serving (wrapping a machine learning model in a Flask API). Flask and Django are complementary, not competing — Django for large full apps, Flask for small focused services.

FastAPI is based on Python type hints (introduced in Python 3.5+). When you define a function with typed parameters, FastAPI automatically: validates incoming data, converts types, and generates documentation. This dramatically reduces bugs. FastAPI is among the fastest Python web frameworks (comparable to Node.js and Go). Key features: Pydantic models for data validation, automatic OpenAPI/Swagger docs, async support natively, OAuth2/JWT authentication built-in. Growing rapidly — seeing FastAPI on a résumé signals the candidate uses cutting-edge Python tooling.

Every Python full-stack developer must know REST API design: HTTP verbs (GET/POST/PUT/PATCH/DELETE), status codes (200 OK, 404 Not Found, 401 Unauthorized), JSON serialization, and URL structure. Authentication: Session-based auth (Django's built-in — stores session server-side); JWT (JSON Web Tokens — stateless, used in modern SPAs); OAuth2 (third-party login — "Login with Google"). Libraries: Pydantic (data validation, used heavily with FastAPI), marshmallow (serialization for Flask), DRF Serializers (Django REST Framework's validation layer). Swagger/OpenAPI documentation is increasingly expected.

Celery is the most popular Python library for background task processing. It requires a message broker — Redis (most common, also serves as a cache) or RabbitMQ. Common use cases: sending emails asynchronously, processing uploads, scheduling periodic tasks (cron-style), data export generation. Celery Beat adds scheduled task support. Django + Celery + Redis is an extremely common production stack. Seeing this combination on a résumé signals experience with high-traffic, production-ready systems.

WSGI (Web Server Gateway Interface) is the Python standard for synchronous web apps — used with Django/Flask. ASGI (Asynchronous Server Gateway Interface) is the modern standard for async apps — used with FastAPI and async Django. Servers: Gunicorn (most common WSGI server, works with Django/Flask); Uvicorn (ASGI server for FastAPI, async applications); Daphne (ASGI, used with Django Channels). Nginx sits in front as a reverse proxy. This stack (Nginx → Gunicorn/Uvicorn → Django/Flask/FastAPI) is the standard Python production deployment pattern.

Jinja2 is the most widely used Python templating engine — used by Flask, FastAPI, and many other frameworks. Django Template Language (DTL) is Django's built-in template system, slightly less powerful than Jinja2 but tightly integrated with Django's security model. Both support loops, conditionals, template inheritance (base templates), and filters (formatting functions). Server-side rendering (SSR) with templates is simpler to deploy than SPAs but less dynamic. Jinja2 is also used for non-HTML templating (email templates, config file generation, etc.).

React (Meta) is the most popular pairing with Python back-ends. Vue.js is lighter and increasingly popular in Python/Django shops. The Python back-end (Django REST Framework, FastAPI) exposes a JSON API; the front-end JavaScript framework consumes it. Key concepts for Python developers: CORS (configuring Python server to accept requests from the React app), JWT auth tokens (React stores the token, sends it with every request), and state management (Redux/Zustand for React, Pinia for Vue). Next.js (React-based) with a Python API is a powerful enterprise combo.

HTMX has become very popular in the Django community for adding interactivity to server-rendered apps without the complexity of a JavaScript framework. Instead of React making API calls and re-rendering, HTMX asks the server for HTML fragments and swaps them into the page. The Django + HTMX combination is growing rapidly as a simpler alternative to the Django + React decoupled approach for applications that don't need full SPA complexity. Alpine.js is often paired with HTMX for small JavaScript behaviors.

CSS knowledge is expected from Python full-stack developers. Bootstrap (older, component-based — easier for beginners, less design flexibility) vs. Tailwind CSS (utility-first — more work upfront but more flexible, increasingly preferred by modern Django/React developers). Responsive design (mobile-friendly layouts) is mandatory. Additional tools: SASS/SCSS (extended CSS with variables and nesting), Django-Tailwind (integrates Tailwind into Django projects). Knowing a CSS framework is expected; knowing both signals a well-rounded developer.

PostgreSQL is the #1 production database for Python/Django applications. Key features: ACID compliance (no data loss), JSON field support (store flexible data in relational DB), full-text search, advanced indexing. PostgreSQL on Heroku, AWS RDS, or Supabase is the most common hosting choice. SQLite is used in development (zero setup — just a file) and for small embedded apps. MySQL is also supported but less common in Python shops. psycopg2 or asyncpg are the Python drivers (libraries that connect Python to PostgreSQL).

Django ORM is built into Django — it defines database tables as Python classes (Models), and migrations track schema changes over time. SQLAlchemy is the most powerful Python ORM, used with Flask and FastAPI — offers both ORM style and raw SQL expression language. Alembic manages SQLAlchemy database migrations (like Django's migrations system). Tortoise ORM and SQLModel (by FastAPI's creator) are async ORMs gaining traction. Seeing "Django migrations" on a résumé means the candidate manages database schema changes safely.

Python libraries for MongoDB: PyMongo (synchronous, official driver — use with Django/Flask); Motor (async MongoDB driver — use with FastAPI). Beanie is an async ODM (Object Document Mapper) for FastAPI + MongoDB. MongoDB Atlas provides cloud-hosted MongoDB. The FARM stack (FastAPI + React + MongoDB) is gaining traction as a modern alternative to Django REST Framework. A Python developer listing "PyMongo" or "Motor" has NoSQL experience — valuable for roles requiring flexible data modeling.

Redis use cases in Python web apps: Caching — storing computed results (Django's cache framework supports Redis via django-redis); Session storage — faster than database sessions; Celery broker — queuing background tasks; Rate limiting — preventing API abuse; Pub/Sub — real-time messaging; Leaderboards — sorted sets for ranking. Libraries: redis-py (official Python client), django-redis (Django integration), aioredis (async, for FastAPI). Redis on a résumé alongside Celery signals production-level performance engineering.

Pytest is the Python testing standard — simpler and more powerful than the built-in unittest. Django's TestCase provides database testing with automatic test database setup/teardown. Factory Boy creates test data. Faker generates realistic fake data for tests. pytest-django integrates pytest with Django. Coverage.py measures what percentage of code is tested. Selenium/Playwright for end-to-end browser testing. TDD (Test-Driven Development) on a résumé signals code quality discipline. A developer who says "we don't write tests" is a production risk for any serious company.

Docker is increasingly standard at mid-to-senior Python developer levels. A Dockerfile defines how to build the container image. docker-compose.yml orchestrates multi-container apps (the Python app, database, Redis, Celery worker all together). Common Python docker-compose stack: web (Django/FastAPI) + db (PostgreSQL) + redis + worker (Celery). Container registries: Docker Hub, AWS ECR, GitHub Container Registry. For production at scale, Docker containers are orchestrated with Kubernetes (K8s) — an advanced skill signaling very senior experience.

Git skills required at every level: branching, merging, rebasing, pull requests, resolving conflicts. GitHub Actions (or GitLab CI/CD) is used to automatically test and deploy Python applications on every code push. A typical Python CI/CD pipeline: push code → GitHub Actions runs pytest → if tests pass, build Docker image → deploy to cloud. Pre-commit hooks (using Black for code formatting, isort for import sorting, Flake8/Ruff for linting) ensure code quality standards before code even reaches the repository.

Python deployment options by experience level: Beginner: Heroku, PythonAnywhere, Railway (simple, git-push deploy); Intermediate: DigitalOcean (Droplets or App Platform), Render, Fly.io; Advanced: AWS (Elastic Beanstalk, ECS, EC2), Google Cloud (Cloud Run), Azure (App Service). Key AWS services for Python developers: EC2 (virtual servers), S3 (file storage for user uploads), RDS (managed PostgreSQL), Lambda (serverless Python functions), ElastiCache (managed Redis). AWS certifications (AWS SAA, AWS Developer) on a Python résumé are strong positive signals for DevOps-inclined roles.

Essential Python code quality tools: Black (auto-formatter — "opinionated," no configuration, the most widely adopted Python formatter); Ruff (extremely fast linter/formatter written in Rust, replacing Flake8+isort+Black in many projects in 2024); isort (sorts import statements); mypy (static type checker for Python type hints); pylint (comprehensive linting). Professional Python teams enforce these via pre-commit hooks and CI/CD pipelines. A candidate who mentions "Black" or "Ruff" signals adherence to professional Python development standards.