26.2. CPU-Bound vs I/O-Bound Work
Table of Contents
Understanding CPU-Bound vs I/O-Bound Work
When you design and optimize backends, you must know what kind of work your application is doing. Almost every performance decision, from choosing async to adding more CPUs, depends on whether your workload is CPU-bound or I/O-bound.
This chapter explains the difference, shows how it impacts Python and web backends, and gives you practical patterns and code examples.
Key idea:
To improve performance, first identify if your code is limited by CPU speed (CPU-bound) or by waiting for input/output (I/O-bound).
Optimizing the wrong thing can waste time and even make performance worse.
Basic Definitions
What is CPU-bound work?
CPU-bound work is work where the main bottleneck is the processor doing calculations.
Examples:
- Heavy number crunching
- Image or video processing
- Encryption or compression
- Complex data transformations in memory
- Running large algorithms like machine learning, pathfinding, etc.
In CPU-bound code, you usually have:
- Long loops that do calculations
- Very little waiting for network, disk, or database
- High CPU usage during the task
What is I/O-bound work?
I/O-bound work is work where the main bottleneck is waiting on external systems.
"I/O" stands for Input/Output, like:
- Network (HTTP requests to other APIs, database queries)
- Disk (reading or writing files)
- External services (email provider, payment gateway, S3, Redis)
In I/O-bound code, you usually have:
- Short bursts of CPU work
- A lot of time spent waiting for I/O operations to finish
- Lower CPU usage, but longer total time due to waiting
Comparing CPU-bound and I/O-bound
| Aspect | CPU-bound | I/O-bound |
|---|---|---|
| Main bottleneck | CPU speed / calculations | Waiting for external resources |
| Typical usage | 80–100% CPU during processing | Low to medium CPU, but long waits |
| Examples | Image resize, encryption, math-heavy API | DB queries, HTTP calls, file uploads/downloads |
| Good solutions | More CPUs, multiprocessing, optimize code | Async I/O, concurrency, caching, faster I/O systems |
| Python threads help? | Usually no (GIL limits) | Yes, can overlap waiting time |
| Async/await helps? | No, CPU still the limit | Yes, can handle many concurrent I/O tasks efficiently |
How to Recognize CPU-Bound vs I/O-Bound in Backends
You rarely see "pure" CPU-bound or "pure" I/O-bound systems. Usually, your endpoint does some combination.
A simple HTTP request in a backend might:
- Parse JSON from the client (CPU)
- Validate data (some CPU)
- Query the database (I/O)
- Process the result (CPU)
- Call a third-party API (I/O)
- Format the response (CPU)
You want to know what dominates the total time.
Rough mental checks
Ask these questions about a slow endpoint:
- Does CPU usage spike to 100% for your process?
- Yes, and stays high during requests: probably CPU-bound.
- No, CPU is low but requests are slow: probably I/O-bound.
- What happens if you run more concurrent requests?
- If latency gets much worse, and CPU is maxed out: CPU-bound.
- If latency grows slowly and CPU is low, but DB or network is busy: I/O-bound.
- If you optimize queries or network calls, do things improve a lot?
- Yes: likely I/O-bound.
- No, but optimizing CPU-heavy functions helps: likely CPU-bound.
Simple Python Examples
A CPU-bound example
This function calculates many square roots. It uses CPU but no external I/O.
import math
def cpu_bound_task(n: int) -> float:
result = 0.0
for i in range(1, n):
result += math.sqrt(i)
return result
result = cpu_bound_task(10_000_000)Characteristics:
- Long running loop
- Only uses CPU and memory
- No network or disk access
An I/O-bound example
This function makes HTTP requests to another service.
import requests
def io_bound_task(urls):
results = []
for url in urls:
response = requests.get(url) # Network I/O
results.append(response.text)
return results
urls = ["https://example.com"] * 10
data = io_bound_task(urls)Characteristics:
- Each
requests.getspends most of its time waiting - CPU is mostly idle while waiting for responses
Concurrency and the Python GIL
Python has a Global Interpreter Lock (GIL) that affects how CPU-bound and I/O-bound tasks behave with threads.
How threads behave
- For I/O-bound tasks, threads work well, because:
- When a thread waits on I/O, it gives back the GIL
- Another thread can run and start or process other I/O
- You can perform many I/O operations "at the same time"
- For CPU-bound tasks, threads in CPython usually do not speed things up, because:
- Only one thread can execute Python bytecode at a time due to the GIL
- Threads take turns using the CPU
- Total CPU time is similar, with extra overhead from thread switching
Important rule:
- Use threads or async for I/O-bound tasks, to overlap waiting time.
- Use multiprocessing or multiple processes for CPU-bound tasks, to use multiple CPU cores.
I/O-Bound Work and Async in Backends
Modern Python backends, like FastAPI, are often built around async I/O to handle many concurrent clients.
I/O-bound example with async
Using httpx and asyncio to fetch many URLs:
import asyncio
import httpx
async def fetch(client: httpx.AsyncClient, url: str) -> str:
response = await client.get(url) # I/O, does not block event loop
return response.text
async def main(urls):
async with httpx.AsyncClient() as client:
tasks = [fetch(client, url) for url in urls]
results = await asyncio.gather(*tasks)
return results
urls = ["https://example.com"] * 10
asyncio.run(main(urls))Here:
- Each
await client.get(url)releases control - While one request waits for the network, others can run
- A single Python process can handle many concurrent I/O-bound tasks
This is ideal for:
- Calling databases with async drivers
- Talking to other services over HTTP
- Reading and writing files without blocking the server
CPU-Bound Work and Multiprocessing
Async and threads do not fix CPU limits. For CPU-heavy tasks you need multiple processes or external workers.
CPU-bound example with multiprocessing
import math
from multiprocessing import Pool, cpu_count
def cpu_bound_task(n: int) -> float:
result = 0.0
for i in range(1, n):
result += math.sqrt(i)
return result
if __name__ == "__main__":
n = 10_000_000
tasks = [n] * cpu_count()
with Pool() as pool:
results = pool.map(cpu_bound_task, tasks)
print(sum(results))Here:
- Each process has its own Python interpreter and its own GIL
- Multiple CPU cores can run your code truly in parallel
- This can speed up CPU-bound tasks almost linearly with core count, until you hit other limits
Web Backend Examples
Example 1: Pure I/O-bound endpoint
# FastAPI-like pseudocode
from fastapi import FastAPI
import httpx
app = FastAPI()
@app.get("/weather")
async def get_weather(city: str):
async with httpx.AsyncClient() as client:
r = await client.get(
"https://api.weather.example.com",
params={"city": city}
)
data = r.json()
# small CPU work to format result
return {"city": city, "temp": data["temperature"]}Characteristics:
- Most time spent calling external weather API
- Very little CPU work per request
- Many such requests can be handled concurrently with async
Example 2: Mixed CPU-bound and I/O-bound
from fastapi import FastAPI
import httpx
import hashlib
app = FastAPI()
def heavy_hash(data: bytes, rounds: int = 100_000) -> str:
digest = data
for _ in range(rounds):
digest = hashlib.sha256(digest).digest()
return digest.hex()
@app.post("/process")
async def process_file(file_url: str):
async with httpx.AsyncClient() as client:
r = await client.get(file_url) # I/O-bound part
content = r.content
hash_value = heavy_hash(content) # CPU-bound part
return {"hash": hash_value}Here:
- Download is I/O-bound
- Hash calculation is CPU-bound
- If many clients use this endpoint, CPU may become the bottleneck
- You might move
heavy_hashto a background worker process
Choosing the Right Tool
Summary table of strategies
| Workload type | Good strategies | Less effective strategies |
|---|---|---|
| I/O-bound | Async I/O, threads, faster network/disk, caching | Multiprocessing alone, more CPU cores only |
| CPU-bound | Multiprocessing, more CPU cores, algorithm tuning | Async/await alone, many threads in CPython |
| Mixed (most APIs) | Async for I/O, offload CPU-heavy parts to workers | Doing everything in a single request thread |
Offloading CPU work in backends
For CPU-heavy operations in a web API:
- Do not block the main request handler with long CPU work
- Use:
- Background workers with Celery or RQ
- Separate microservices for CPU-heavy processing
- Message queues (Redis, RabbitMQ) to hand off tasks
Pattern:
- API receives request
- API enqueues a CPU-heavy job to a worker
- API responds quickly with a job ID
- Client checks job status or uses webhooks
This turns a CPU-bound synchronous endpoint into an I/O-bound flow, where the main service mostly deals with I/O: queue messages, job status, etc.
Measuring and Confirming the Bottleneck
Do not guess. You should measure.
Common approaches:
- Profilers for CPU usage
- Show which functions use the most CPU time
- Application metrics
- Track request latency, DB query times, external calls times
- System metrics
- CPU utilization
- Disk I/O
- Network throughput
If:
- CPU is high, and function-level profiling shows hotspots, your app is CPU-bound.
- CPU is low, but DB or network time per request is high, your app is I/O-bound.
Practical rule:
Always measure where the time goes, then label your main bottleneck as CPU-bound or I/O-bound.
Only then choose between:
- Async/threads and I/O optimizations
- Or multiprocessing/CPU scaling and algorithm optimizations.
How This Connects to Performance and Scalability
Later topics in performance and scalability, like:
- Asynchronous programming
- Database optimization and indexing
- Connection pooling
- Caching
- Load balancing and horizontal scaling
all depend on this distinction.
In practice:
- If your bottleneck is I/O, you often get huge wins from:
- Async I/O
- Better queries
- Caching
- Pooling and connection reuse
- If your bottleneck is CPU, you often get huge wins from:
- Using more processes / more machines
- Optimizing algorithms
- Offloading heavy work to background workers
Understanding CPU-bound vs I/O-bound work is the foundation for choosing the right performance strategy for your backend.
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!