20.11. Alerting
Table of Contents
Why Alerting Matters
Monitoring tells you what is happening. Alerting tells someone that action is needed.
Alerting connects your system metrics, logs, and checks to humans or automated responders. Without alerting, you only find incidents when a user complains or when you look at dashboards manually.
Good alerting helps you:
- Detect problems quickly.
- Notify the right people.
- Respond before users are heavily impacted.
- Avoid burnout from constant noisy alerts.
Important: A monitoring system without alerting is almost useless in production. A bad alerting system can be worse than none, because it causes alert fatigue and real incidents get ignored.
Types of Alerts
You can think of alerts in several categories. This helps you design them more clearly.
By Source
| Source | Examples | Tools (typical) |
|---|---|---|
| Metrics | CPU, memory, request rate, error rate | Prometheus + Alertmanager |
| Logs | Specific error patterns, spikes in exceptions | Loki, Elasticsearch, Datadog Logs |
| Traces | Slow spans, failing services | Jaeger, Tempo, X-Ray, etc. |
| Synthetic | Health check endpoints from outside | UptimeRobot, Pingdom, custom |
Metrics-based alerts are usually the core of backend alerting. Log- and trace-based alerts are often used for specific conditions or debugging recurring failures.
By Purpose
| Purpose | Description | Example |
|---|---|---|
| Availability alerts | Service is down or unusable | Health check failing for 5 minutes |
| Performance alerts | Service is slow, but still works | p95 latency exceeds 500 ms for 10 minutes |
| Error-rate alerts | Too many errors compared to normal | 5xx rate > 2% of all responses for 10 minutes |
| Capacity / saturation | Running out of resources | DB connections > 90% of pool size for 15 minutes |
| Business / product alerts | Business KPI problems, fraud detection | Checkout success rate drops below 80% |
| Security alerts | Suspicious or malicious behavior | Many failed logins from same IP |
By Urgency
You cannot treat all alerts the same. If you do, your on-call engineers will burn out.
Typical severities:
| Level | Meaning | Example |
|---|---|---|
| Critical | Immediate user impact, wake someone up | API completely down, payments failing globally |
| High | Serious, fix during working hours | Error rate increased, but system still mostly usable |
| Medium | Needs investigation soon | Background worker queue growing unusually fast |
| Low | Observation or suggestion | Disk usage > 70%, plan to increase volume size |
Rule: Only Critical alerts should wake people at night. Everything else should be routed as lower-priority notifications.
Basic Alerting Concepts
To work with alerting tools, you should understand some common concepts.
Alert Rules
An alert rule is a condition plus some metadata about what to do.
Example in human language:
Trigger "High error rate" alert when 5xx responses are more than 5% of total responses for 10 minutes.
Common fields in an alert rule:
| Field | Description |
|---|---|
| Name | Human-readable name of the alert |
| Expression | The condition, often based on metrics |
| Threshold | The value that indicates a problem |
| Duration | How long the condition must be true |
| Severity | How urgent it is |
| Labels/tags | Info for routing (service, team, environment) |
| Description | What the alert means and how to handle it |
In Prometheus, for example, the condition is a PromQL expression like:
rate(http_requests_total{status=~"5.."}[5m])
/
rate(http_requests_total[5m])
> 0.05
You usually also specify a for: 10m duration so it only fires if the condition is true for 10 minutes.
Thresholds and SLOs
A threshold is the value where you decide something is too bad to tolerate.
Instead of picking random thresholds, production teams often define SLOs (Service Level Objectives), for example:
- 99.9% of requests should succeed.
- p95 latency for
GET /api/ordersshould be under 400 ms.
Then they build alerts around violations of these SLOs, or around being close to violating them.
Example pattern:
Pattern: Alert on symptoms, not just causes.
Instead of "CPU > 90%", prefer "Error rate > 2%" or "Latency > SLO".
High CPU alone might not hurt users. High error rate definitely does.
Alert States: Firing, Pending, Resolved
Most alerting systems have states like:
- Inactive: Condition is false.
- Pending: Condition is true, but not long enough yet.
- Firing: Condition has been true longer than the configured
forduration. - Resolved: Condition was firing, now condition is false again.
You typically only notify humans when the alert is firing. Some systems also send a "resolved" notification when things recover.
What to Alert On
For backend systems, some alert types are especially common.
Uptime and Health Checks
Use health endpoints that your service exposes, for example /healthz or /live.
Typical alerts:
- HTTP 5xx from health endpoint for X minutes.
- Health endpoint not reachable from public internet.
Example service-level alert:
- "If health check fails from 3 different locations for 5 minutes, send Critical alert."
Error Rates
Instead of only counting errors, compare them to all requests.
Let:
- $E(t)$ be the number of error responses in time window $t$.
- $R(t)$ be the total number of responses in time window $t$.
Then the error rate is:
$$
\text{error\_rate}(t) = \frac{E(t)}{R(t)}
$$
Rule: Alert on ratio, not just raw counts.
5 errors per second could be trivial if you handle 10,000 requests per second, but huge if you only handle 20.
Example alert:
- If
error_rate(5m) > 0.05(5%) for 10 minutes, severity = Critical.
Latency (Response Time)
Latency describes how long requests take. Instead of an average, you want percentiles like p95 or p99, because outliers hurt users even if the average looks okay.
Example:
- "p95 latency for
POST /api/orders> 800 ms for 15 minutes."
Resource Saturation
Monitor when you are close to limits:
- CPU usage as a percentage.
- Memory usage, or high GC activity.
- Disk space usage.
- Number of open file descriptors.
- Database connections in use.
- Queue length for background jobs.
You usually want capacity alerts to be warning-level, giving you time to act before a hard failure.
Examples:
- Disk usage > 85% for 30 minutes: High severity.
- DB connection usage > 90% for 10 minutes: High severity.
Business and Security Signals
Over time, you add alerts closer to business impact, for example:
- Drop in successful logins.
- Sudden spike in failed payments.
- Many failed login attempts from same IP or user account.
These are just metrics like any other, but they require thinking about business behavior.
Alert Destinations and Routing
An alert that no one sees is useless. You must send alerts to places where someone will react.
Common Destinations
| Destination | Use case |
|---|---|
| Non-urgent notifications, summaries | |
| Chat (Slack etc) | Team visibility, most alerts |
| Pager apps | Critical alerts, wake on-call engineer |
| Ticketing (Jira) | Track follow-up work on recurring problems |
| Webhooks | Trigger automation, runbooks, or other tools |
For Critical alerts in production, teams usually integrate alerting with:
- An on-call rotation system (PagerDuty, Opsgenie, etc).
- Phone calls, push notifications, or SMS.
Routing by Labels or Tags
Alerts often carry labels such as:
service = "payments-api"team = "payments"environment = "production"severity = "critical"
Then your alert manager uses routing rules:
- All alerts with
environment = productionandseverity = criticalgo to on-call. - Alerts with
team = paymentsgo to a specific Slack channel. - Alerts from
environment = stagingonly send to low-priority channel.
This way, the right team sees the right alerts.
Avoiding Alert Fatigue
Alert fatigue happens when engineers receive so many alerts that they stop paying attention. This is very common in badly configured systems.
Common Causes of Bad Alerts
- Alerting directly on every single exception event.
- Using thresholds that are too low, causing alerts for normal behavior.
- No
forduration, so any short spike creates alerts. - Duplicate alerts from multiple rules for the same problem.
- Alerts firing for non-production environments with same urgency as production.
Good Practices
Use these guidelines to keep alerts useful:
- Start with a small, critical set.
Focus on availability, error rates, and very bad performance first. - Use a "for" period.
Require the condition to be true for several minutes before firing. - Group related alerts.
Many alerting systems can group alerts by service or cluster, sending a single message about multiple instances failing. - Tune thresholds over time.
Look at real metric histories before picking values. Adjust if you see frequent false positives. - Silence during maintenance.
When deploying or doing maintenance, silence relevant alerts, or mark deployments to avoid false alerts. - Review incidents.
After a real incident or a noisy alert, update the alert rules. Bad alerts should be fixed or removed.
Rule: Every firing alert should be:
- Actionable: You can do something specific.
- Owned: A team is clearly responsible.
- Relevant: It indicates real or likely user impact.
If an alert fails any of these, change or delete it.
Writing Useful Alert Messages
The content of an alert is as important as the condition. At 3 AM, someone half-asleep must understand it quickly.
A good alert should answer:
- What is broken?
Which service, which environment, which region. - How bad is it?
Severity, error rate, affected users if known. - What should I check first?
Links to dashboards, logs, and maybe a runbook. - What changed recently?
Often the cause is a recent deployment or config change.
Example: Bad vs Good Alert
Bad message:
"Error alert: high error count"
Good message:
`[CRITICAL][payments-api][production] 5xx error rate > 10% for 15m
Affected: /api/payments/*
Check: https://grafana.example.com/d/abcd/payments-api
Runbook: https://wiki.example.com/payments-api-runbook#high-error-rate`
The good example includes context, severity, and pointers to next steps.
Basic Alerting with Prometheus and Alertmanager
In many modern backends with Prometheus and Grafana, alerting works like this:
- Prometheus collects metrics from your services.
- You define alert rules in Prometheus.
- When a rule fires, Prometheus sends alert data to Alertmanager.
- Alertmanager groups, deduplicates, and routes alerts to email, Slack, paging tools, etc.
An abbreviated example of an alert rule (in YAML) could look like:
groups:
- name: backend.rules
rules:
- alert: HighErrorRate
expr: rate(http_requests_total{status=~"5.."}[5m])
/
rate(http_requests_total[5m]) > 0.05
for: 10m
labels:
severity: critical
service: payments-api
environment: production
annotations:
summary: "High 5xx error rate on payments-api"
description: "Error rate > 5% for more than 10m in production."Alertmanager configuration then decides:
- Where to send alerts with
severity = critical. - How to group alerts.
- Who is on-call for
service = payments-api.
You do not need to master these tools yet, but understanding this flow helps you design your backend metrics and health checks so they can feed into alerting later.
Alerting and On-Call
In many teams, real-time alerting is connected to an on-call rotation. That is a schedule where one engineer is responsible for handling Critical alerts.
Key ideas:
- Only truly urgent alerts should page on-call.
- On-call engineers should have access to:
- Dashboards.
- Logs.
- Runbooks (step-by-step guidance).
- Incidents that wake people up should lead to:
- A review of the alert.
- A fix to avoid similar alerts if they were not helpful.
As a backend developer, you contribute by:
- Exposing good metrics and health checks.
- Suggesting useful alert rules.
- Writing simple runbooks for recurring failure modes in your service.
Summary
Alerting is the bridge between your backend systems and human or automated responses. It builds on monitoring and observability, uses thresholds on metrics and logs, and routes information to the right people and tools.
Keep in mind:
- Start with a small, critical set of alerts about availability, error rates, and latency.
- Use severity levels, "for" durations, and routing rules to prevent noise.
- Ensure every alert is actionable, owned, and relevant.
- Improve your alerts whenever they misfire during real incidents.
With well-designed alerting, your backend can fail gracefully, and your team can respond quickly without being overwhelmed.
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!