20.7. Health Checks
Table of Contents
Why Health Checks Matter
When your backend is running in production, you need an automated way to answer two questions at any moment:
- Is the application alive?
- Is the application healthy enough to serve real traffic?
Health checks are the mechanism that answers these questions for load balancers, orchestrators like Kubernetes, uptime monitors, and your own dashboards.
A backend that responds to requests is not always healthy.
Never assume “it returns 200” means “everything is fine”.
In this chapter we focus on how to design, implement, and use health checks in a backend system, not on the general topics of logging or monitoring that are covered elsewhere.
Basic Health Check Types
Most systems expose at least two distinct kinds of checks:
| Check type | Typical name / path | Question answered |
|---|---|---|
| Liveness | /live, /healthz | Is the process running at all? |
| Readiness | /ready, /readiness | Can this instance handle real traffic? |
Sometimes you may also see:
| Check type | Typical name / path | Question answered |
|---|---|---|
| Startup | /startup | Has the app fully started and initialized? |
| Deep / full | /health, /deep-health | Are key dependencies healthy, like DB and Redis? |
Liveness Checks
A liveness check answers: “Should this process be killed and restarted?”
It must be:
- Very fast
- Very simple
- Very reliable
A typical liveness check only verifies that:
- The web server loop is running.
- The application can execute simple in-memory logic.
- Optionally, critical internal components are not obviously broken.
Example in words:
- If the liveness endpoint returns a success status, the orchestrator keeps the container/pod alive.
- If it fails repeatedly, the orchestrator restarts it.
What you usually do not check in liveness:
- Database availability.
- External APIs.
- Message queues.
Those belong in readiness or deeper health checks.
Rule: Liveness checks should almost never depend on external systems.
If a downstream dependency is down, you want to degrade or fail requests, not kill the process.
Readiness Checks
A readiness check answers: “Can this instance safely receive production traffic right now?”
This endpoint can be slower and more complex. It typically checks:
- Database connectivity (can you open a connection and run a simple query?).
- Cache connectivity (e.g. ping Redis).
- Message broker availability (e.g. ping RabbitMQ or Kafka).
- Application-level conditions (e.g. background workers warmed up, migrations completed).
If readiness fails:
- The orchestrator or load balancer removes the instance from rotation, but usually does not kill it.
- The instance can recover and become ready again without a restart.
Example scenarios that make an instance “not ready”:
- Database is temporarily overloaded or unreachable.
- App is starting up and still loading a big model or cache.
- App is draining connections before a rolling deployment.
Designing Health Check Endpoints
Well designed health checks share a few common properties.
Clear and Stable URLs
Pick simple, conventional paths and keep them stable:
- Liveness:
/liveor/healthz - Readiness:
/readyor/readiness - Deep health:
/health
Avoid long or “clever” URLs like /check_if_everything_is_ok_now. Many tools assume simple paths.
HTTP Status Codes and Format
Use HTTP status codes to signal result:
- Healthy:
200 OK - Unhealthy:
503 Service Unavailableis common - Starting up / not ready yet: Also often
503for readiness
The body format should be:
- Machine readable (JSON).
- Simple and consistent.
Example JSON response:
{
"status": "ok",
"details": {
"database": "ok",
"redis": "ok",
"queue": "degraded"
}
}
Rule: Health checks must use HTTP status codes correctly.
Do not return 200 OK for a failing health check with an "error" message in the body.
Minimal Authentication
Many systems make health endpoints accessible without auth from:
- Internal load balancers.
- Orchestrators (Kubernetes).
- Uptime monitoring services.
Options:
- No auth but restricted by IP or network (e.g. only internal VPC).
- Simple token in a header:
X-Health-Token: <secret>. - Mutual TLS for sensitive environments.
Be careful not to expose sensitive implementation details in public health endpoints.
Lightweight Implementation
Health endpoints must not become a performance problem.
Guidelines:
- Keep liveness extremely cheap (often just return
200immediately). - Cache results of expensive checks for a short time (for example 5 to 30 seconds).
- Avoid long blocking calls.
Example strategy for readiness:
- Perform expensive checks at an interval in a background task.
- Store the latest result in memory.
- Health endpoint returns that stored result instantly.
Application-Level vs Dependency-Level Checks
A good health check distinguishes between:
- The status of the application itself.
- The status of its dependencies.
Application-Level Health
Application-level checks include:
- The main event loop is running.
- Configuration loaded successfully.
- Critical background tasks are alive.
- No fatal errors that would prevent handling requests.
For example, a simple check:
- Try to allocate a small object.
- Confirm a shared in-memory cache is accessible.
- Verify that the current deployment version is loaded.
Dependency-Level Health
Common dependencies to check:
| Dependency type | Typical check |
|---|---|
| Database | Connect and run SELECT 1 |
| Redis | PING command |
| Message broker | List queues or ping broker |
| Third-party API | Simple “ping” or trivial business request |
The result can be represented like:
{
"status": "degraded",
"details": {
"app": "ok",
"database": "down",
"redis": "ok",
"payment_provider": "timeout"
}
}How you interpret this:
- Liveness might still be
"ok"if the app process is fine. - Readiness might be
"false"because database is"down".
Rule: Separate “can the process run?” from “can the app fulfill its purpose?”.
Liveness is about the process. Readiness is about usefulness.
Example Health Check Designs
Below are high level examples you can adapt to any backend framework.
Minimal Liveness Endpoint
Pseudocode:
@app.get("/live")
def live():
return {"status": "ok"}This only checks that the HTTP server and app are responding.
Readiness with Dependency Checks
Pseudocode with simple checks:
@app.get("/ready")
def ready():
checks = {}
# Database
try:
db.execute("SELECT 1")
checks["database"] = "ok"
except Exception:
checks["database"] = "down"
# Redis
try:
redis_client.ping()
checks["redis"] = "ok"
except Exception:
checks["redis"] = "down"
overall = "ok"
if "down" in checks.values():
overall = "unhealthy"
status_code = 200 if overall == "ok" else 503
return JSONResponse(
status_code=status_code,
content={"status": overall, "details": checks}
)Typical behavior:
- If both DB and Redis are up, returns
200. - If either is down, returns
503and the failing component is visible indetails.
Startup Health Check
During startup, the app may need to:
- Run database migrations.
- Load configuration or secrets.
- Warm up caches.
Example idea:
- Expose
/startupthat only returns200once all initialization is complete. - Kubernetes and similar systems can use this to delay routing traffic until startup succeeds.
Pseudocode:
startup_done = False
@app.on_event("startup")
def on_startup():
global startup_done
# initialization code here
startup_done = True
@app.get("/startup")
def startup():
if startup_done:
return {"status": "ok"}
raise HTTPException(status_code=503, detail="Starting up")Integrating Health Checks with Infrastructure
Health checks become powerful when integrated with other components.
Load Balancers
Load balancers (like Nginx, HAProxy, AWS ALB) can:
- Periodically call your health endpoint.
- Remove instances from rotation if checks fail.
- Add them back when checks pass again.
Example configuration idea:
- Use
/readyfor traffic decisions. - Use relatively short timeouts and intervals, such as:
- Interval: 5 to 10 seconds.
- Healthy threshold: 2 successful checks.
- Unhealthy threshold: 2 to 3 failed checks.
Container Orchestration (Kubernetes Example)
Kubernetes uses different probes:
| Probe | Typical endpoint | Purpose |
|---|---|---|
| liveness | /live | Restart pod if probe fails |
| readiness | /ready | Send or stop sending traffic |
| startup | /startup | Allow long startups gracefully |
Descriptive behavior:
- If liveness fails repeatedly, Kubernetes kills and restarts the pod.
- If readiness fails, the pod stays running but is removed from Service endpoints.
- If startup probe fails, Kubernetes will restart the pod, but until it passes, liveness and readiness are ignored.
Uptime Monitoring Tools
External tools like:
- UptimeRobot
- Pingdom
- StatusCake
will periodically call a health or homepage URL.
Best practice:
- Expose a public friendly endpoint like
/healththat: - Returns
200only when you want to show “service is up” on your status page. - Might be less detailed than internal health checks.
If your app is partially degraded but not fully down, you can still decide to return 200 and show a “degraded performance” status at the application or business level.
Health Checks and Graceful Shutdown
During deployments or maintenance your app should:
- Stop accepting new traffic.
- Finish in-flight requests.
- Shut down cleanly.
Health checks help coordinate this.
A typical sequence:
- Mark the instance as not ready:
- Readiness endpoint starts returning
503or"ready": false. - Load balancer removes the instance from rotation.
- Instance continues to handle current in-flight requests until they finish.
- After a timeout, the process exits.
Example behavior for a shutdown hook:
- During shutdown, set a flag so
/readyreturns unhealthy. - Keep
/livereturning healthy until very close to final termination.
This avoids:
- Dropped requests during rolling deployments.
- Restart loops caused by health checks failing too early.
Health Check Best Practices
To close, here is a compact list of practical rules you can follow when designing and implementing health checks.
Health Check Rules:
- Separate liveness and readiness.
Liveness answers “should I restart?” Readiness answers “should I send traffic?” - Keep liveness cheap and internal.
No external calls, minimal logic, very fast. - Check dependencies in readiness or deep health.
Database, cache, and external APIs belong here. - Use proper HTTP status codes.
200 OKfor healthy,503 Service Unavailablefor unhealthy. - Make responses machine readable and simple.
Use JSON with a clearstatusand optionaldetails. - Do not expose sensitive info.
Avoid secrets, internal hostnames, or stack traces in public health endpoints. - Cache expensive checks when necessary.
Use short-lived in-memory caching to reduce load. - Integrate with infrastructure.
Configure load balancers, orchestrators, and uptime monitors to use these endpoints. - Test failure scenarios.
Simulate DB down, slow dependencies, or partial outages and confirm health behavior. - Document your health endpoints.
Other teams and tools should know which paths to call and how to interpret responses.
By following these practices, your backend becomes more observable, resilient, and friendly to automated systems that keep it running reliably in production.
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!