5.15. Async Programming
Table of Contents
Why Async Programming Matters for Backend Development
When you build backends, most of the time the bottleneck is not CPU, but waiting for external systems, for example:
- Waiting for a database query to finish
- Waiting for an HTTP call to another service
- Waiting for a file to be read from disk
During this waiting time, your program can either:
- Block and do nothing, or
- Continue doing useful work for other requests
Asynchronous programming is about writing code that can pause while it waits for I/O, and resume later, so the same process can handle many things at once.
In Python backends, this is especially important when you build servers with frameworks like FastAPI or when you call many external APIs.
Async programming lets one process handle many I/O bound tasks by not blocking while it waits. It does not magically make CPU bound code faster.
Synchronous vs Asynchronous: The Core Idea
Synchronous (Blocking) Code
In classic Python code, each line waits for the previous one to finish:
import time
def fetch_user():
print("Fetching user...")
time.sleep(2) # simulating slow I/O
print("User fetched")
return {"id": 1}
def fetch_orders():
print("Fetching orders...")
time.sleep(3) # simulating slow I/O
print("Orders fetched")
return [{"id": 101}, {"id": 102}]
def main():
user = fetch_user()
orders = fetch_orders()
print("Done")
main()Timeline:
- 0–2 seconds: waiting for user
- 2–5 seconds: waiting for orders
- Total: about 5 seconds
During each sleep, the program is doing nothing, just blocking.
Asynchronous (Non‑Blocking) Code
With async, you can start both operations, then await them:
import asyncio
async def fetch_user():
print("Fetching user...")
await asyncio.sleep(2)
print("User fetched")
return {"id": 1}
async def fetch_orders():
print("Fetching orders...")
await asyncio.sleep(3)
print("Orders fetched")
return [{"id": 101}, {"id": 102}]
async def main():
user_task = asyncio.create_task(fetch_user())
orders_task = asyncio.create_task(fetch_orders())
user = await user_task
orders = await orders_task
print("Done")
asyncio.run(main())Timeline:
- 0–2 seconds: both tasks run, both can pause and yield time
- 2–3 seconds: only orders is still running
- Total: about 3 seconds, not 5
Because while fetch_user is waiting, fetch_orders can use the same event loop.
The Event Loop and `async` / `await`
What Is the Event Loop?
The event loop is the core piece that:
- Tracks which async functions are currently running
- Switches between them when they
awaitsomething - Resumes them when the awaited operation is done
You usually do not manage the loop directly. Frameworks like FastAPI or libraries like asyncio.run handle it.
In a backend server, the event loop continuously:
- Accepts new incoming connections.
- Passes requests to your async endpoint functions.
- Pauses and resumes them as they await I/O.
Declaring Async Functions
An async function is defined with async def:
async def say_hello():
return "Hello"You cannot call it like a normal function if you want its result. This is coroutine, not a plain value.
result = say_hello()
print(result) # <coroutine object say_hello at 0x...>
To actually run it, you must await it from inside another async function, or use asyncio.run at the top level.
async def main():
result = await say_hello()
print(result) # "Hello"
import asyncio
asyncio.run(main())Rule:
- Use
async defto define asynchronous functions. - Use
awaitto pause and wait for an async operation inside an async function. - You cannot use
awaitat the top level of a regular script.
`await` Makes the Function Pause, not Block the Thread
When you write:
await asyncio.sleep(1)You are saying:
I am waiting for 1 second, but during this time, the event loop is free to run other tasks.
If you call the blocking time.sleep(1) inside async code, you freeze the whole loop for 1 second and block other requests. That is a common mistake.
Basic `asyncio` Building Blocks
asyncio is the standard library module for asynchronous programming in Python.
Running an Async Program
This pattern is common in simple scripts:
import asyncio
async def main():
print("Before")
await asyncio.sleep(1)
print("After")
if __name__ == "__main__":
asyncio.run(main())
In a web backend framework, you usually do not call asyncio.run yourself. The framework does something similar internally.
Sequential vs Concurrent `await`
Two awaits in a row are still sequential:
async def main():
await asyncio.sleep(2) # first wait 2s
await asyncio.sleep(3) # then wait 3s
# total ~5s
To run them concurrently, you can use asyncio.gather:
async def main():
await asyncio.gather(
asyncio.sleep(2),
asyncio.sleep(3),
) # total ~3sOr create tasks:
async def main():
task1 = asyncio.create_task(asyncio.sleep(2))
task2 = asyncio.create_task(asyncio.sleep(3))
await task1
await task2Both ways let the event loop juggle multiple operations at once.
Example: Calling Multiple APIs in Parallel
Imagine a backend that needs:
- User data from
https://api.example.com/user/1 - Orders from
https://api.example.com/user/1/orders
With asynchronous HTTP client httpx:
import asyncio
import httpx
async def fetch_user(client):
resp = await client.get("https://api.example.com/user/1")
return resp.json()
async def fetch_orders(client):
resp = await client.get("https://api.example.com/user/1/orders")
return resp.json()
async def main():
async with httpx.AsyncClient() as client:
user_task = asyncio.create_task(fetch_user(client))
orders_task = asyncio.create_task(fetch_orders(client))
user, orders = await asyncio.gather(user_task, orders_task)
print(user)
print(orders)
asyncio.run(main())A web API endpoint can use the same pattern to respond faster.
Async I/O vs CPU Bound Work
Async Shines for I/O Bound Work
I/O bound means your program spends most of its time waiting for:
- Database queries
- Network calls
- Disk operations
Async code can handle many such operations at once in a single process.
Example: A FastAPI server that:
- Awaits database queries
- Awaits calls to third party APIs
The same process can serve many concurrent requests.
Async Does Not Speed Up CPU Heavy Code
CPU bound work consumes CPU directly, for example:
- Image processing
- Complex data analysis
- Compression or encryption loops
Async does not give your CPU more power. This function:
def slow_cpu_work():
total = 0
for i in range(10_000_000):
total += i
return total
If you simply put async in front:
async def slow_cpu_work():
total = 0
for i in range(10_000_000):
total += i
return total
It is still CPU bound and will block the event loop until it finishes, because there is no await inside.
To handle CPU heavy work in a backend, you usually:
- Move it to a background worker (see background processing chapters).
- Or run it in a separate process or thread pool from async code.
Async programming improves concurrency for I/O bound tasks, not raw CPU speed. Do not expect async to speed up heavy calculations.
Mixing Async and Sync Code Safely
In real projects you often need to use:
- Async frameworks and libraries.
- Legacy sync libraries (for example a database driver).
Calling Synchronous Code from Async
If you call a blocking function directly from async code, it will freeze the event loop:
import time
async def handler():
time.sleep(2) # BAD inside async code
return "Done"
Use asyncio.to_thread to run blocking code in a thread pool:
import asyncio
import time
def blocking_task():
time.sleep(2)
return "Done"
async def handler():
result = await asyncio.to_thread(blocking_task)
return resultThis is very useful when you integrate a library that has no async version.
Example: Synchronous File Read in Async Code
Synchronous version:
def read_file(path: str) -> str:
with open(path, "r", encoding="utf-8") as f:
return f.read()Async safe wrapper:
import asyncio
async def read_file_async(path: str) -> str:
return await asyncio.to_thread(read_file, path)
You can then use read_file_async in async endpoints.
Async in Web Backends: Conceptual View
You will see async again in the chapters about FastAPI and asynchronous endpoints. Here is how it fits conceptually.
Async Endpoints
In an async capable framework, an endpoint can look like this:
# conceptual example, not tied to a specific framework
async def get_user_handler(request):
user_id = request.path_params["user_id"]
user = await fetch_user_from_db(user_id) # async DB call
orders = await fetch_orders_for_user(user_id) # async DB call
return {
"user": user,
"orders": orders,
}
While fetch_user_from_db and fetch_orders_for_user wait for the database, the event loop can process other incoming requests.
If you have 100 concurrent requests, the server can interleave their work instead of blocking on each one.
When to Use Async in Backends
Some simple backends work fine with synchronous code. Async is especially helpful when:
- You expect high concurrency (many users at the same time).
- Your app does a lot of networking on each request (calls other services, APIs).
- You want to keep resource usage low for many open connections.
If your backend is small and simple, synchronous code may be easier to reason about. Use async when you start to hit scalability or latency issues, or when you use frameworks that are designed for async (like FastAPI).
Common Pitfalls and Best Practices
Pitfall 1: Using Blocking Libraries in Async Code
Example of a blocking HTTP client in async code:
import requests # blocking
import asyncio
async def fetch_data():
response = requests.get("https://example.com") # blocks the loop
return response.textBetter: use an async client:
import httpx
import asyncio
async def fetch_data():
async with httpx.AsyncClient() as client:
response = await client.get("https://example.com")
return response.text
If you must use a blocking library, wrap it in asyncio.to_thread.
Pitfall 2: Forgetting to `await`
If you forget await, the coroutine is created but not executed:
async def say_hi():
print("Hi")
async def main():
say_hi() # missing await, nothing runs
import asyncio
asyncio.run(main())Correct:
async def main():
await say_hi()Pitfall 3: Overusing Concurrency
Creating too many tasks can overload external systems.
Example of risky code:
async def fetch_all(urls):
tasks = [
asyncio.create_task(fetch_single(url))
for url in urls
]
return await asyncio.gather(*tasks)
If urls has thousands of entries, you might:
- Open thousands of connections.
- Overload the remote server or your own machine.
Better: limit concurrency with a semaphore:
import asyncio
semaphore = asyncio.Semaphore(10) # allow 10 at a time
async def fetch_single_limited(url):
async with semaphore:
return await fetch_single(url)Pitfall 4: Mixing Async and Sync Frameworks Incorrectly
Trying to call async code from a synchronous web framework (like a classic WSGI framework) or the other way around can be tricky and inefficient. In practice, choose:
- An async capable framework for async code.
- Or use sync code with sync frameworks.
Practical Mini Exercises (Mentally or in a REPL)
Try these small tasks to become familiar with async patterns.
Exercise 1: Convert Sync to Async
- Write a synchronous function that uses
time.sleep(1)three times in a loop and prints a counter. - Convert it to async using
asyncio.sleep(1). - Run it with
asyncio.run.
Exercise 2: Parallel Sleep
Write an async function:
async def wait_and_print(seconds, name):
await asyncio.sleep(seconds)
print(f"{name} done after {seconds} seconds")
Then run three of them concurrently with asyncio.gather and observe that the total time is close to the maximum of the seconds, not their sum.
Exercise 3: Wrap Blocking Code
Create a blocking function that reads a large file with open and read. Then:
- Wrap it with
asyncio.to_thread. - Create multiple async tasks that read the file in parallel.
- Print how long it takes.
Summary
- Async programming in Python uses
async def,await, and an event loop to handle many I/O bound tasks concurrently. - It is especially valuable in backend development where requests often wait for databases, other services, or the network.
- Use
awaitinside async functions to pause and free the event loop to serve other tasks. - Use async capable libraries (for example
httpx.AsyncClient) and avoid blocking calls in async code, or wrap them withasyncio.to_thread. - Async improves concurrency and scalability for I/O bound workloads, not raw CPU performance.
In later chapters, when you work with FastAPI and background tasks, you will apply these async concepts directly to real backend applications.
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!