28.4. Graceful Shutdown
Table of Contents
Why Graceful Shutdown Matters
When a backend process stops, it can do so in two ways:
- Hard (abrupt) shutdown: the process is killed immediately. Ongoing requests are cut off, in‑flight database writes may be interrupted, and clients see errors or timeouts.
- Graceful shutdown: the process stops cooperatively. It stops accepting new work, completes or cancels current work safely, cleans up resources, and then exits.
In production systems you almost always want graceful shutdown. It is important for:
- User experience: active requests finish instead of failing in the middle of an action.
- Data integrity: you avoid half-finished writes and inconsistent state.
- System stability: resources like DB connections and file handles are released.
- Zero‑downtime deployment: you can upgrade or restart services without breaking traffic.
A production backend must always implement a graceful shutdown procedure that:
- Stops accepting new work.
- Waits for in‑flight work to complete or times it out.
- Closes connections and external resources safely.
- Exits with a clear, predictable state.
Throughout this chapter we will look at patterns and concrete examples that you can adapt to your stack, with a focus on Python and async backends.
Signals and Process Lifecycle
On Unix-like systems (Linux, macOS) processes receive signals that tell them to stop or change behavior.
Common termination signals:
| Signal | Typical source | Meaning in our context |
|---|---|---|
SIGINT | Ctrl+C in a terminal | Interrupt, usually used in development |
SIGTERM | systemd, Kubernetes, Docker stop | Please terminate, used in production |
SIGKILL | Kernel, kill -9 | Forced kill, cannot be caught |
For graceful shutdown, we care about catchable signals, mainly SIGTERM and sometimes SIGINT.
High-level graceful shutdown flow:
- Process receives
SIGTERM. - A signal handler sets a flag, triggers cleanup logic, or stops servers.
- Servers stop accepting new connections.
- Ongoing requests get a chance to finish.
- Timeouts and resource cleanup run.
- Process exits with status code 0 (success).
If your process ignores SIGTERM, orchestration systems may escalate to SIGKILL, which gives you no chance to shut down gracefully.
Basic Pattern: Stop Accepting New Work
The first step of a graceful shutdown is to stop taking on new work.
For a web server, that means:
- Stop accepting new connections.
- Stop routing new requests to workers.
- Optionally respond to new connections with a quick error during the drain period.
A common approach is to:
- On shutdown signal, close the listening socket or mark the server as shutting down.
- Allow existing connections to continue and finish.
In higher-level frameworks (like Uvicorn + FastAPI) this is often handled by the server. Your responsibility is to:
- Integrate with the server’s shutdown hooks.
- Make sure your own background and long-running work respects shutdown signals.
Tracking In‑Flight Requests
To avoid killing ongoing work, you need a way to know when it is safe to exit. A simple pattern is to track how many requests are currently running.
In pseudocode:
in_flight_requests = 0
shutting_down = False
def before_request():
global in_flight_requests
if shutting_down:
raise RejectNewRequests()
in_flight_requests += 1
def after_request():
global in_flight_requests
in_flight_requests -= 1
def handle_shutdown():
global shutting_down
shutting_down = True
wait_until(in_flight_requests == 0 or timeout_reached)
In an async Python service, you might do something similar with an asyncio.Lock or asyncio.Semaphore.
This pattern makes it possible to:
- Immediately reject new requests while
- Allowing current requests to finish.
Timeouts and Maximum Shutdown Duration
You cannot wait forever. There will always be a request that hangs, a database that is slow, or a bug that delays completion.
So you usually combine:
- Request timeouts: every request must finish within a maximum duration.
- Shutdown timeout: the process will wait up to a limit, then forcefully stop any remaining tasks.
Typical shutdown timeout values are 10 to 60 seconds, depending on your workload.
Always define a maximum shutdown timeout, for example:
$$ T_{\text{shutdown\_max}} = 30\ \text{seconds} $$
After $T_{\text{shutdown\_max}}$ expires, the process must exit even if work is still pending, otherwise deployments and scaling operations can hang.
In Kubernetes, for example, the terminationGracePeriodSeconds setting defines how long the platform will wait after sending SIGTERM before sending SIGKILL.
Graceful Shutdown in Async Python
Many modern backends use asyncio and async frameworks. In async systems, graceful shutdown is mostly about:
- Cancelling tasks in a controlled way.
- Awaiting their completion.
- Distinguishing between "soft cancellation" and "forceful stop".
A typical pattern:
import asyncio
import signal
shutdown_event = asyncio.Event()
def _signal_handler():
shutdown_event.set()
async def main():
loop = asyncio.get_running_loop()
loop.add_signal_handler(signal.SIGTERM, _signal_handler)
loop.add_signal_handler(signal.SIGINT, _signal_handler)
# Start background tasks
worker_task = asyncio.create_task(background_worker())
# Wait for shutdown signal
await shutdown_event.wait()
# Begin graceful shutdown
worker_task.cancel()
try:
await worker_task
except asyncio.CancelledError:
pass
# Clean up resources here (DB, Redis, etc.)
asyncio.run(main())Key ideas:
- A signal sets some shared state (
shutdown_event). - Background workers check for cancellation and exit.
- Tasks are cancelled and awaited so that any
finallyblocks run.
Coordinating with Web Servers (Uvicorn / Gunicorn / Nginx)
Graceful shutdown is not just your application. It is the whole chain:
- Load balancer / reverse proxy (Nginx, HAProxy, cloud LB).
- Application server (Gunicorn, Uvicorn workers).
- Application code (FastAPI, Django, etc.).
- Background workers (Celery, RQ, custom asyncio workers).
Each layer has a role.
Typical production flow:
- Load balancer marks the instance as draining so it does not receive new connections.
- Load balancer keeps existing connections alive for a grace period.
- System sends
SIGTERMto the app server process. - App server:
- Stops accepting new connections.
- Lets current requests finish.
- Signals workers to shut down.
- Your app:
- Releases resources.
- Stops background tasks.
You need to ensure your application hooks run, for example:
- In FastAPI, use lifespan events or custom startup/shutdown events.
- In Django, use signals or WSGI/ASGI server hooks.
- For custom workers, add explicit signal handling as shown above.
Handling Database Connections and Pools
Databases maintain connections that are expensive to create. You usually use a connection pool.
During graceful shutdown, you must:
- Stop creating new DB connections.
- Let ongoing transactions finish or roll back.
- Close connections in the pool cleanly.
If you use an ORM, it likely provides a method such as:
- SQLAlchemy:
engine.dispose()orsession.close_all(). - An async engine:
engine.dispose()withawait.
Example pattern (pseudocode):
async def on_shutdown():
# Stop accepting new requests, wait for ongoing ones ...
# Close DB connection pool
await async_engine.dispose()If you do not close the pool, the OS will eventually free the resources when the process exits, but some drivers or libraries may not flush buffered data or metrics correctly.
Also ensure that long-running transactions are avoided in your design, because they make graceful shutdown harder. Use shorter transactions and commit frequently.
Shutting Down Background Workers and Queues
Web requests are not the only form of work. You may have:
- Message queue consumers (e.g., listening to RabbitMQ, Kafka).
- Periodic job schedulers.
- Custom background loops (pollers, event listeners).
For each of these:
- On shutdown signal, ask the worker to stop fetching new jobs.
- Let the current job finish (or interrupt it in a safe way).
- Acknowledge or requeue jobs appropriately.
- Close connections to the broker.
Example pattern with an async worker loop:
async def worker(shutdown_event):
while not shutdown_event.is_set():
job = await queue.get()
try:
await handle_job(job)
finally:
queue.task_done()
When shutdown_event is set:
- The loop stops after the current job.
- You can also implement a drain timeout to avoid a job running forever.
In job systems like Celery, built‑in signals and commands handle much of this, but you still need to design your tasks to be idempotent and able to resume if interrupted.
Draining Traffic Behind a Load Balancer
In a production environment, your backend is usually behind a load balancer or ingress controller.
You typically combine two mechanisms:
- Instance draining at the load balancer:
- Stop routing new requests to a particular instance.
- Keep existing connections alive for a configured delay.
- Process-level graceful shutdown:
- The instance still serves the connections it has.
- It waits for those requests to finish.
Typical Kubernetes scenario:
- Pod is marked for termination.
- Kubernetes sends
SIGTERMto containers. - At the same time, the pod is removed from the service endpoints, so the service stops sending new requests.
- Pod has up to
terminationGracePeriodSecondsto finish ongoing work and exit.
Similar concepts exist in cloud load balancers, like ALB/NLB in AWS, where you configure:
- Connection draining or deregistration delay.
- Health checks that determine when instances are ready or not.
Coordinating these settings with your app’s shutdown timeout is important. If the load balancer stops routing traffic too late, you may still receive new requests already in your shutdown phase.
Handling Long‑Running and Streaming Requests
Some endpoints may:
- Stream data for a long time (e.g. Server‑Sent Events, WebSockets).
- Perform long calculations.
- Process very large uploads or downloads.
For such endpoints you must decide:
- Allow them to complete even if shutdown is slow, or
- Cut them off at a configured limit and tell the client to retry or resume.
Options include:
- Imposing maximum request duration on the server side.
- Implementing resumable operations or idempotent retries:
- For uploads, use chunked uploads or presigned URLs.
- For long jobs, offload to background workers and return a job ID, then the worker can continue independently of the web server lifecycle.
It is usually a bad idea to keep a process alive indefinitely just because one client has kept a streaming connection open. Use a reasonable time limit for such connections.
Observability During Shutdown
To understand and trust your shutdown behavior, you should:
- Log the start and end of shutdown:
- Received
SIGTERM - Number of in‑flight requests
- Time spent draining
- Log errors during cleanup:
- Problems closing DB pools
- Exceptions in background tasks
- Export metrics:
- Count of active requests.
- Number of forced cancellations.
- Shutdown duration.
This helps you answer questions like:
- How often do we hit the shutdown timeout limit?
- Are there frequent tasks that ignore cancellation?
- Is our termination grace period misconfigured?
A Typical Graceful Shutdown Checklist
Use this as a practical reference when implementing graceful shutdown in a backend service.
Graceful Shutdown Checklist
- Signal handling
- Handle
SIGTERM(and optionallySIGINT). - Trigger a shutdown event instead of exiting immediately.
- Stop accepting new work
- Stop accepting new web requests.
- Stop fetching new jobs from message queues.
- Track in‑flight work
- Maintain a count or registry of active requests / jobs.
- Wait for them to finish, subject to a maximum shutdown timeout.
- Timeouts
- Set per‑request or per‑job timeouts.
- Set a global shutdown timeout $T_{\text{shutdown\_max}}$.
- Release resources
- Close DB connections and pools.
- Close Redis, message broker, file handles, and external client connections.
- Cooperate with load balancers
- Ensure instance draining is configured.
- Coordinate LB grace period with your shutdown timeout.
- Logs and metrics
- Log shutdown steps and durations.
- Expose metrics related to shutdown success / failures.
- Test it
- Simulate
SIGTERMin staging or local environment. - Verify that:
- No new requests are accepted.
- Ongoing requests finish successfully.
- The process exits within the configured time.
By following these patterns, you can make your backend behave predictably under restarts, deployments, and failures, which is essential for reliable production systems.
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!