20.8. Monitoring
Table of Contents
Why Monitoring Matters
Monitoring is how you see what your backend is doing in real time. Logs tell you what happened. Monitoring tells you how things are going right now, and whether you need to act.
Some problems you can only catch by monitoring:
- Traffic spikes that overload your database
- Memory leaks that slowly grow until the process crashes
- Slow endpoints that hurt user experience but do not fail
- External services (payment, email, etc.) going slow or down
Without monitoring you often only learn about problems when users complain.
Important: Monitoring is about continuous measurement of system health and performance, not about debugging single requests. Use logs for details, use monitoring for trends and alerts.
In this chapter we focus on the concepts of monitoring. Specific tools like Prometheus and Grafana are covered in their own chapters.
Key Concepts in Monitoring
Metrics vs Logs vs Traces
You already saw logging earlier. Monitoring mainly works with metrics and sometimes traces.
- Logs
- Text, event based
- Example:
"User 123 created order 456" - Good for: debugging a specific error, understanding exact flows
- Metrics
- Numbers, aggregated over time
- Example:
requests_per_second = 124,error_rate = 0.8% - Good for: dashboards, alerts, trends, capacity planning
- Traces (covered more under Observability)
- Show how a single request moves through multiple services
- Example: user request → API → database → email service
Monitoring focuses mostly on metrics.
Types of Metrics
You will see the same few metric types again and again.
1. Counters
A counter only goes up, never down, except when the process restarts.
Examples:
- Total HTTP requests:
http_requests_total - Total errors:
http_errors_total - Total sent emails:
emails_sent_total
Example in pseudo code (Python style):
http_requests_total += 1
if response.status_code >= 500:
http_errors_total += 1You do not reset counters manually. Monitoring systems calculate rates from them, like requests per second.
2. Gauges
A gauge can go up and down.
Examples:
- Current CPU usage:
cpu_usage_percent - Current memory usage:
memory_used_bytes - Open DB connections:
db_connections_open - Queue length:
jobs_waiting_in_queue
Example:
db_connections_open = get_current_connection_count()3. Histograms / Summaries
These measure distributions, such as:
- Request duration
- Response sizes
- DB query times
They let you answer:
- How many requests finished in under 100 ms?
- What is the 95th percentile latency?
Example labels:
http_request_duration_seconds_bucket{
path="/api/orders",
method="GET",
le="0.1"
} 1234
This says: 1234 GET /api/orders requests finished in ≤ 0.1 seconds.
Rule of thumb:
Use counters for counts, gauges for "current values", and histograms for latencies and sizes. Do not store every value as a log if you only need aggregated behavior, use metrics.
What You Should Monitor
You cannot monitor everything. Start with the most important signals.
The “Four Golden Signals”
A very common model is the four golden signals of monitoring:
| Signal | Question it answers | Examples |
|---|---|---|
| Latency | How fast are requests? | Request duration, DB query time |
| Traffic | How much work is the system doing? | Requests per second, messages per second |
| Errors | How often do things fail? | Error rate, failed jobs, 5xx responses |
| Saturation | How “full” is the system? | CPU, memory, queue length, DB connections |
These give a high level picture of system health.
Latency
You care about:
- Overall average latency (not very useful alone)
- Percentiles like p95 or p99
Example:
- p50 (median) = 40 ms
- p95 = 450 ms
- p99 = 2 seconds
This tells you some users have a bad experience, even if the average looks fine.
Traffic
Examples:
- HTTP requests per second
- Tasks enqueued per minute
- Emails sent per minute
Use traffic metrics to:
- Spot sudden spikes
- See the effect of marketing campaigns
- Plan capacity
Errors
Important metrics:
- HTTP 5xx rate, e.g.
% of responses with status_code >= 500 - Failed background jobs
- Failed database transactions
- Failed external API calls
Often you define an error budget, for example:
Example error budget:
Up to 0.1% of all requests may fail in a month. If you exceed that, you must spend time on reliability before adding new features.
Saturation
Saturation shows how close you are to the limits:
- CPU usage, e.g. 80%
- Memory usage, e.g. 90% of RAM used
- DB connection pool usage, e.g. 95% connections in use
- Queue length growing over time
If saturation is always high, you may need more instances or optimization.
Application-Level Monitoring
System metrics like CPU and RAM are useful. But you also need application metrics that reflect your business and logic.
Technical Application Metrics
Common examples:
| Metric | Description |
|---|---|
http_requests_total | Total HTTP requests |
http_requests_in_flight | Requests currently being processed |
http_request_duration_seconds | Request duration histogram |
db_queries_total | Total DB queries |
db_query_duration_seconds | DB query time histogram |
jobs_queued_total | Jobs pushed to background queue |
jobs_failed_total | Failed jobs |
Add labels to metrics, for example:
method(GET, POST, etc.)endpoint(/api/orders,/api/users/{id})status_code(200, 400, 500)
Example in pseudo code:
increment("http_requests_total", labels={
"method": request.method,
"endpoint": "/api/orders",
"status_code": response.status_code,
})Do not create labels with unbounded values such as user IDs, email addresses, or random strings. That will explode your metric storage.
Important rule:
Metric label values should come from small, fixed sets like HTTP methods or a limited set of endpoints.
Never put user IDs, request IDs, or arbitrary strings in labels.
Business Metrics
Business metrics describe what the application achieves, not just how it runs.
Examples:
orders_created_totalpayments_failed_totalactive_users_gaugecart_abandon_rateemails_verification_sent_total
These help answer:
- Did a bug reduce the number of orders per hour?
- Is payment success rate dropping after a deployment?
- Are many users failing to log in?
Business metrics are often more important than purely technical ones, because they show real user impact.
Infrastructure Monitoring
Monitoring should not stop at your application. You also monitor the environment it runs in.
Host and Container Metrics
Examples:
| Metric | Description |
|---|---|
cpu_usage_percent | CPU usage per host or container |
memory_used_bytes | RAM usage |
disk_used_percent | Disk usage |
network_rx_bytes_total | Received bytes over network |
network_tx_bytes_total | Sent bytes over network |
With containers and orchestration (for example Docker, Kubernetes), you also monitor:
- Container restarts
- Container CPU and memory limits
- Pod status (Running, CrashLoopBackOff, etc.)
Dependency and External Service Monitoring
Dependencies often fail:
- Database
- Cache (Redis)
- Message queue
- Payment provider
- Email provider
- Third party APIs
For each important dependency, measure:
- Availability: Can you connect?
- Latency: How long do calls take?
- Error rate: How many calls fail?
Example:
external_api_requests_total{service="payments", status="success"} 1532
external_api_requests_total{service="payments", status="error"} 27When external services become slow, your own system may become slow too. Monitoring helps you detect this quickly.
Health Checks and Probes
Monitoring tools and load balancers often call health endpoints to check if your application is alive and ready.
Liveness vs Readiness
Two useful concepts:
- Liveness probe
- Answers: "Should this process be restarted?"
- Example: returns 200 OK if main loop is running
- If it fails, something is very wrong and restart is needed
- Readiness probe
- Answers: "Can this instance receive traffic?"
- Example: checks database connection, migration status, etc.
- If it fails, the load balancer should stop sending requests to this instance, but not necessarily restart it
Typical FastAPI style example:
@app.get("/health/live")
def liveness():
# If code runs, return OK
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
if not db_is_connected():
raise HTTPException(status_code=503, detail="DB not ready")
return {"status": "ready"}Monitoring systems can watch these endpoints and alert if they fail.
Rule:
Expose simple, fast health endpoints.
Liveness should only check if the process is alive.
Readiness should check if dependencies are usable.
Dashboards
Dashboards present metrics in a way humans can understand quickly.
What to Put on a Dashboard
You usually create multiple dashboards:
- Overview dashboard
- Requests per second
- Error rate
- p95 latency
- CPU, memory, database connections
- API performance dashboard
- Latency per endpoint
- Error rate per endpoint
- Successful vs failed calls to external services
- Background jobs dashboard
- Jobs queued vs processed
- Failed jobs per worker
- Job processing latency
- Business dashboard
- Orders per minute
- Payment success rate
- Signups per hour
The main rule: keep them simple enough to understand in a stressful situation.
Example Dashboard Layout
| Row | Graphs |
|---|---|
| 1 | Requests per second, Error rate |
| 2 | p95 latency overall, p95 latency by main endpoints |
| 3 | CPU and memory, DB connections and query duration |
| 4 | Queue length, failed jobs per minute |
Alerting
Monitoring is useless if nobody reacts. Alerting notifies you when metrics cross dangerous thresholds.
Alert Rules
Typical alert rules:
- High error rate
- Condition:
5xx_error_rate > 2% for 5 minutes - Meaning: Many users see server errors
- High latency
- Condition:
p95_latency > 1s for 10 minutes - Meaning: Most users experience slow responses
- Resource saturation
- Condition:
cpu_usage_percent > 90% for 15 minutes - Condition:
db_connections_in_use > 95% - Unavailable health check
- Condition:
/health/readyfailing for 3 checks in a row
Example rule in plain language:
If http_5xx_error_rate is above 5% for 10 minutes, send a critical alert to the on-call channel.
Alert Channels
Common channels:
- Chat tools (Slack, Teams, etc.)
- Pager tools (PagerDuty, Opsgenie, etc.)
- SMS or phone call for critical alerts
You want:
- Low noise: Do not alert for everything. Too many alerts and people ignore them.
- High value: Every alert should mean "someone must look now".
Alert Priorities
Usually you define levels:
| Level | Example | Action |
|---|---|---|
| Info | New version deployed | No immediate action |
| Warning | Latency slightly higher than normal | Investigate during working hours |
| Critical | High error rate affecting many users | Immediate action, wake up on-call engineer |
Monitoring in Different Environments
You usually have at least:
- Development
- Staging / testing
- Production
Monitoring is most important in production, but other environments are useful too.
Production
- Full monitoring and alerting
- SLOs (service level objectives) and error budgets
- Dashboards for on-call and product teams
Staging / Testing
- Lighter monitoring
- Used to test end to end flows
- Check new deployments before going to production
Example:
- After deployment to staging, monitor error rate and latency for a while.
- If metrics look bad, fix before deploying to production.
Local Development
You normally do not need full monitoring locally, but you might:
- Expose a few metrics
- Try the metrics endpoint manually
- Verify that health checks work
Common Monitoring Pitfalls
Too Many Metrics
It is easy to instrument everything. That can create problems:
- High storage costs
- Slow dashboards
- Hard to find important metrics
Guidelines:
- Start with the four golden signals and a small set of business metrics.
- Remove unused metrics from dashboards.
- Think before adding labels.
Missing Context
If you only see "error rate high", that is not enough.
Combine metrics with:
- Logs for details about errors
- Traces for which step is slow or failing
- Deployment information (version, time of last deployment)
Example: after a deployment at 12:05, latency jumps at 12:07. This gives you a strong hint that the deployment caused the issue.
No Clear Ownership
If everyone owns monitoring, sometimes nobody does. Decide:
- Who maintains alert rules
- Who is on call
- Who keeps dashboards up to date
How Monitoring Fits With Logging and Observability
Monitoring is one part of a bigger picture often called observability.
A simple mental model:
| Layer | Purpose |
|---|---|
| Logging | Understand specific events and errors |
| Monitoring | Watch system health and performance over time |
| Tracing | Follow a single request through the system |
You will often:
- Receive an alert from monitoring.
- Look at dashboards to confirm there is a problem.
- Check logs or traces to find the exact cause.
Monitoring connects high level symptoms (error rate up, latency up) to detailed investigation (logs, traces).
Summary
- Monitoring is about continuous measurement of system health and performance, mainly using metrics.
- Focus on the four golden signals: latency, traffic, errors, saturation.
- Use counters, gauges, and histograms for different kinds of data.
- Monitor both technical metrics and business metrics.
- Add clear health checks for liveness and readiness.
- Build dashboards that are easy to read during incidents.
- Configure alerts for meaningful, user impacting problems, not everything.
- Combine monitoring with logs and traces for full understanding.
Next chapters will show concrete tools like Prometheus and Grafana, and how to implement monitoring 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!