22.1. Application Servers
Table of Contents
Why You Need an Application Server
When you run a backend application in production, you do not usually expose your framework directly to the internet. Instead, you run it inside a dedicated application server process.
An application server is a program that:
- Listens for HTTP requests on a port.
- Runs your application code for each request.
- Manages multiple requests at the same time.
- Handles timeouts, errors, and graceful shutdown.
It sits between your code and the outside world, often behind a reverse proxy such as Nginx or Traefik.
Typical Python examples are Uvicorn and Gunicorn. In this chapter we focus on the general ideas that apply to application servers and will look at specific ones in the next chapters.
Key idea: Do not run your development server in production. Always use a proper application server that is designed for concurrency, robustness, and performance.
Application Server vs Development Server
Most backend frameworks come with a development server:
- Flask has
flask run - Django has
python manage.py runserver - FastAPI examples often show
uvicorn main:app --reloadfor local development
These are convenient but are not tuned or hardened for production.
Typical differences:
| Feature | Development Server | Application Server |
|---|---|---|
| Performance | Basic | Optimized, often supports async and workers |
| Concurrency | Often single process, maybe single thread | Multiple workers, async event loops, threads |
| Reliability | Crashes easily, not self-healing | Designed to handle load and errors gracefully |
| Hot reload | Yes, auto restart on code change | No, must be restarted via process manager |
| Security | Minimal | Configurable limits, timeouts, and isolation |
| Use case | Local development | Staging and production |
You should:
- Use the framework’s dev server or
--reloadmode locally. - Use a real application server, often behind a reverse proxy, in production.
Where Application Servers Fit in the Stack
A typical production web stack looks like this:
- Client
Browser, mobile app, or another service. - Reverse proxy (Nginx / Traefik)
- Terminates HTTPS
- Handles TLS certificates
- Routes requests to the correct backend service
- Can serve static files directly
- Application server (Uvicorn / Gunicorn / Uvicorn + Gunicorn combo)
- Speaks HTTP (or ASGI/WSGI internally)
- Manages worker processes or async event loops
- Runs your application code for each request
- Your application code
- Framework such as FastAPI, Django, Flask
- Contains your business logic
- Databases, caches, external services
- PostgreSQL, Redis, third‑party APIs, etc.
Example flow:
- User hits
https://api.example.com/users. - Nginx receives the encrypted request on port 443, decrypts it, and forwards it (for example) to
http://127.0.0.1:8000. - The application server listens on
127.0.0.1:8000, chooses a worker, and invokes your application. - Your application queries the database, builds a response, and returns it to the server.
- The application server sends the HTTP response back to Nginx, which sends it back to the client.
Concurrency Models in Application Servers
One of the important jobs of an application server is to handle many requests at the same time. There are several models.
1. Single process, single thread
This is the simplest model:
- One process.
- One thread.
- Handles one request at a time.
This is common in simple development servers. It is not suitable for real-world traffic.
2. Multi process
The server starts multiple worker processes:
- Each process is a separate copy of your application.
- Different processes may run on different CPU cores.
- The operating system distributes connections between processes.
Example configuration idea:
- 1 master process.
- 4 worker processes.
Each worker can handle multiple requests over time. If one worker crashes, the master can start a new one.
3. Multi thread
The server starts threads inside a single process:
- One process.
- Many threads.
- Each thread can handle a request.
Threads share memory, so they can be faster to start. But bugs can affect all threads, and some languages have limitations with threads.
4. Asynchronous / event loop
In async servers:
- A single process (or several processes) runs an event loop.
- Each request is represented as a task.
- When a task is waiting for I/O (for example database query, HTTP call), the event loop runs another task instead of blocking.
This is very useful for I/O‑bound web apps, which is common in backend development.
Many modern application servers support combinations, for example:
- Multiple processes, each with an async event loop.
- Threads used for certain blocking tasks.
Rule of thumb: CPUs are good at running multiple processes, and async is good at handling many I/O-bound requests. Application servers usually combine these techniques for better throughput.
Worker Processes and How to Choose Their Number
An application server usually exposes a parameter like --workers to set how many worker processes to run.
A common heuristic:
Recommended worker formula:
For CPU‑bound workloads:
$$ \text{workers} \approx 2 \times \text{CPU\_cores} $$
For I/O‑bound workloads:
$$ \text{workers} \approx 2 \times \text{CPU\_cores} + 1 $$
Adjust based on memory and real-world testing.
Example:
- Your server has 4 CPU cores.
- For an I/O-bound FastAPI service, you might start with
workers = 2 * 4 + 1 = 9workers.
You then:
- Run load tests.
- Monitor CPU usage, memory usage, and response times.
- Increase or decrease worker count.
If you choose too few workers:
- Requests queue up.
- Response time grows under load.
If you choose too many workers:
- Each worker gets less memory.
- The OS spends more time context switching.
- Performance may get worse.
Timeouts, Keep‑Alive, and Connection Handling
Application servers need careful configuration of timeouts and connections.
Typical parameters:
- Request timeout
Maximum time the server waits for the request body to arrive.
Prevents very slow clients from holding connections forever. - Response timeout / worker timeout
Maximum time a worker may spend handling a single request.
Protects you from stuck code or extremely slow database calls. - Keep‑alive timeout
How long to keep the TCP connection open after a response, to reuse for future requests from the same client.
Example situations:
- If your worker timeout is 30 seconds and a database query hangs for 2 minutes, the server will kill the worker and possibly start a new one.
- If your keep‑alive timeout is 5 seconds, the server will close idle connections after 5 seconds of inactivity.
You will often configure timeouts both:
- In the reverse proxy (like Nginx).
- In the application server.
They must be compatible. For instance, if the proxy closes connections after 10 seconds but your app server expects 60 seconds, long responses might be cut off by the proxy.
Graceful Shutdown and Restart
When you deploy new versions or stop your server, you want a graceful shutdown:
- The server stops accepting new connections.
- Existing requests are allowed to finish up to a limit.
- Workers are then stopped.
- Resources such as database connections are cleaned up.
Benefits:
- No interrupted in-flight requests when you deploy.
- Reduced errors during restarts.
Application servers usually:
- Listen for OS signals like
SIGTERMorSIGINT. - Trigger a shutdown procedure that gives workers a grace period.
Example scenario:
- The server has a graceful timeout of 30 seconds.
- You send a
SIGTERM(for example your orchestrator stops the container). - The server stops accepting new requests, and lets current requests finish.
- After 30 seconds, any remaining workers are killed.
For rolling or zero-downtime deployments, you often run two or more instances and restart them one at a time, so there is always at least one healthy instance behind the reverse proxy.
Handling Errors at the Server Level
Your application will raise exceptions, time out, and sometimes crash. A good application server:
- Catches unhandled exceptions, logs them, and returns an HTTP 500 instead of crashing the entire process.
- Uses worker isolation so that a crash in one worker does not affect others.
- Optionally limits request size to avoid memory exhaustion.
- Configures maximum concurrent connections or requests per worker.
Common error-related settings include:
- max request size
For example, refuse bodies larger than 10 MB at the application server level. - max requests per worker
Restart a worker after it has served a certain number of requests.
This can help mitigate memory leaks in application code. - logging level and format
Server logs often include access logs (per request) and error logs.
Example idea:
You configure a server so that:
- Each worker is restarted after 10,000 requests.
- Each request must finish within 30 seconds.
- Each request body must not exceed 2 MB.
If an attacker tries to send a 500 MB POST body, the server can reject the request early, without your application trying to read it all into memory.
Application Servers and Protocols (HTTP, WSGI, ASGI)
Application servers speak two sides:
- External side:
HTTP over TCP connections from clients or a reverse proxy. - Internal side:
A protocol specific to your application type, for example: - WSGI for classic synchronous Python web applications.
- ASGI for asynchronous Python applications and WebSockets.
- Other ecosystems have their own standards.
Your application is usually a callable that the server invokes according to that protocol.
Simplified idea:
- WSGI:
The server calls your app likeresponse = app(environ, start_response). - ASGI:
The server calls an async callable that communicates over send/receive callables.
You rarely need to implement these protocols yourself, but you should understand:
- Some servers support only WSGI.
- Some support only ASGI.
- Some can act as a bridge or support both via different worker classes.
This matters when you choose a server for a specific framework.
Example: Running an Application Server Locally (Conceptual)
Imagine you have a file main.py:
# main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello from production-style server"}Using an application server might look like:
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4Even without going into Uvicorn specifics yet, note what happens conceptually:
- The application server imports
main, finds theappobject. - It opens a listening socket on
0.0.0.0:8000. - It starts 4 worker processes.
- Each incoming HTTP request is routed to one of the workers.
- The worker runs your FastAPI app to build a response.
- The server sends the response to the client.
If your code crashes in one worker, the server can replace that worker.
Application Servers Behind a Reverse Proxy
Although some application servers can listen directly on the public network interface, in production you usually:
- Bind the application server to a private address, such as
127.0.0.1:8000or10.x.x.x:8000. - Let Nginx or Traefik accept public traffic on ports 80 and 443.
- Let the reverse proxy forward traffic to the application server.
Benefits:
- Reverse proxy handles HTTPS and TLS certificates.
- You can run multiple backend services, each with its own application server, behind a single entry point.
- Extra security by not exposing the application server directly to the internet.
- Easier migration or blue/green deployments by just changing proxy config.
Conceptual Nginx snippet:
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
Nginx receives the request, then passes it to your application server at 127.0.0.1:8000.
Monitoring and Observing Application Servers
To keep your backend healthy, you need to observe how your application server behaves.
Useful metrics and logs:
| Metric / Log | Why it matters |
|---|---|
| Requests per second | Shows traffic volume |
| Average and percentile latency | Shows how fast responses are |
| Error rate (5xx responses) | Shows instability |
| Worker count and worker restarts | Detects crashes or memory leaks |
| CPU and memory usage per process | Helps choose worker counts and instance sizes |
Application servers often have:
- Command line options for logging levels.
- Integration points for metrics exporters.
- Signals or endpoints to report health.
You will combine these with external tools for logging and monitoring in later chapters.
Summary
In this chapter you learned what application servers are and why they are critical for production backend systems:
- They sit between your code and the outside world, often behind a reverse proxy.
- They manage worker processes, threads, or async event loops for concurrency.
- They enforce timeouts, limits, and handle errors at the process level.
- They support protocols like WSGI or ASGI to call your application code.
- They enable graceful shutdown, rolling deployments, and better observability.
In the next chapters you will see how to use Uvicorn and Gunicorn specifically as Python application servers, and how to combine them with reverse proxies in real deployments.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!