20.5. Error Logging
Table of Contents
Why Error Logging Matters
When something goes wrong in your backend, users usually see only a generic error message. You see nothing, unless you log it.
Error logging is the process of recording information about problems that happen in your application. Without it, you are effectively blind in production. With it, you can:
- Detect bugs and failures quickly.
- Reproduce and fix issues that are hard to trigger locally.
- Measure how stable your system is.
- Prove that an incident is resolved because related errors stop appearing.
Important: A backend in production must always have structured, centralized error logging. Relying on print statements or local log files is not enough.
This chapter focuses on logging errors specifically, not general application logging or metrics, which are covered elsewhere.
What Counts as an Error?
Not everything that looks bad is an error, and not every error is equally important. It helps to classify problems so you can react correctly.
Types of errors
Some common categories:
| Category | Example | Should you log? |
|---|---|---|
| Programming bugs | ZeroDivisionError, KeyError, AttributeError | Always |
| Data validation | User sends invalid email or missing required field | Usually, at lower level |
| External failures | Database timeout, Redis connection error, email server | Always |
| Client misuse | 404 on random path, invalid API key | Often, but not as errors |
| Security-related | Many failed logins, suspicious inputs, SQLi attempts | Yes, and monitor closely |
Many frameworks attach a log level to each log entry:
DEBUGfor internal details.INFOfor normal operations.WARNINGfor something odd but not critical.ERRORfor a failure in the current operation.CRITICALorFATALfor complete breakdowns.
For error logging, you mostly work with ERROR and CRITICAL.
Rule: Use ERROR when a request or job fails but the system still runs. Use CRITICAL only when the whole application or a key component is unusable.
Logging Exceptions Correctly
Errors in backend code often appear as exceptions. It is not enough to log "Error happened". You need:
- The exception type, message, and full stack trace.
- Context like which request caused it.
Example: naive vs proper exception logging
Imagine a route that fails:
def divide(a, b):
return a / b
try:
result = divide(1, 0)
except Exception:
print("Something went wrong")This tells you nothing. A better version:
import logging
logger = logging.getLogger(__name__)
try:
result = divide(1, 0)
except Exception:
logger.exception("Error while dividing numbers")
logger.exception:
- Automatically logs at
ERRORlevel. - Captures the full stack trace.
- Records the exception type and message.
Equivalent pattern if you already have the exception object:
except Exception as exc:
logger.error("Error while dividing numbers", exc_info=exc)In a web framework, you often do this in middleware or error handlers instead of every route.
Example: logging errors in a request handler
Pseudo code for a generic HTTP handler:
def handle_request(request):
try:
return process_request(request)
except Exception:
logger.exception("Unhandled error in request handler")
return make_500_response()This pattern:
- Logs all unhandled exceptions with full details.
- Returns a safe HTTP 500 response without leaking internals.
Including Context in Error Logs
A stack trace is helpful, but context turns a log into a real debugging tool.
What context should you include?
For a typical web request, useful fields are:
- Request path, method, and query.
- Correlation or request ID.
- Authenticated user ID, if available.
- Client IP (carefully, see privacy).
- Relevant parameters, but never sensitive data.
Example of a structured context dictionary:
context = {
"path": request.path,
"method": request.method,
"query": dict(request.query_params),
"user_id": request.user.id if request.user else None,
"request_id": request.headers.get("X-Request-ID"),
}Then:
logger.exception("Unhandled error in HTTP request", extra=context)If you use JSON logging, these context keys become fields in the JSON object.
Example: missing context problem
Log without context:
ERROR:root:Database error
Traceback (most recent call last):
...
psycopg2.OperationalError: timeoutYou know the database failed, but not which request. With context:
{
"level": "ERROR",
"msg": "Database error",
"exception": "psycopg2.OperationalError: timeout",
"path": "/orders/checkout",
"method": "POST",
"user_id": 42,
"request_id": "8a1f6b8c-...-e2f1"
}Now you can:
- Filter errors by
pathoruser_id. - Search logs using
request_idthat is also present in access logs.
Separating Client Errors from Server Errors
Not every failed request is a server error. This matters for both HTTP status codes and logging.
Mapping HTTP codes to log levels
A common pattern:
| HTTP status | Meaning | Log level suggestion |
|---|---|---|
| 2xx | Success | Usually no error log |
| 3xx | Redirect | INFO at most |
| 4xx (client error) | Client input or behavior | INFO or WARNING |
| 5xx (server error) | Server failed | ERROR or CRITICAL |
For example:
- User sends invalid data, you return 400 with a clear message. This is normal use, log at
INFOor not at all, or aggregate metrics. - Your database is down and a 500 error is sent. This is a server error worth logging at
ERRORor higher.
Example: logging 4xx vs 5xx
Imagine a validation error:
def create_user(request):
data = request.json()
if "email" not in data:
logger.info("User creation failed, missing email", extra={"path": "/users"})
return json_response({"error": "email is required"}, status=400)
...And a server error:
def create_user(request):
try:
...
db.save(user)
except DatabaseTimeoutError:
logger.exception("Database timeout when creating user")
return json_response({"error": "Internal server error"}, status=500)This keeps your error logs focused on things you must fix on the server side.
Avoiding Sensitive Data in Logs
Error logs often capture request information and data values. That is useful, but it is dangerous if you log sensitive data.
Sensitive data examples:
- Passwords and password hashes.
- Access tokens, refresh tokens, API keys.
- Full credit card numbers and CVV codes.
- Personal identifiable information (PII), such as passport numbers.
- Sensitive health or financial details.
Rule: Never log passwords, tokens, or full payment details. Mask or remove sensitive fields before logging.
Example: masking sensitive fields
Suppose you receive this JSON:
{
"email": "user@example.com",
"password": "secret123",
"credit_card": "4111111111111111"
}Do not log it directly. Instead, sanitize it:
def sanitize_payload(payload: dict) -> dict:
masked = {}
for key, value in payload.items():
if key.lower() in {"password", "token", "api_key"}:
masked[key] = "***"
elif key.lower() in {"credit_card", "card_number"} and isinstance(value, str):
masked[key] = value[:4] + "****" * 3
else:
masked[key] = value
return maskedThen in your error logging:
try:
process_payment(payload)
except Exception:
safe_payload = sanitize_payload(payload)
logger.exception("Payment processing failed", extra={"payload": safe_payload})This keeps logs useful but safe to share with teammates and support staff.
Centralized Error Logging
In a real system, you typically have many instances of your backend running on multiple servers or containers. Looking at local log files is not practical.
Instead, you send error logs to a centralized logging or error tracking system.
What centralized error logging gives you
- A single place to search and filter errors from all instances.
- Grouping of similar errors into issues.
- Dashboards showing error rates over time.
- Alerts when error rates exceed thresholds.
- Ability to add tags like version or environment.
Common patterns:
- Use a logging backend (like Elasticsearch with Kibana, Loki, or a SaaS log service) for all logs.
- Use a dedicated error tracking service (like Sentry, Rollbar, etc.) specifically for exceptions.
Example: attaching environment and version
When logging errors, attach metadata:
logger.exception(
"Unhandled error",
extra={
"env": "production",
"service": "orders-api",
"version": "1.3.5",
}
)In a centralized system, this lets you:
- Filter by environment, for example see only
productionerrors. - See if an error started after version
1.3.5. - Check if a fix in
1.3.6reduced the error count.
Error Aggregation and Deduplication
In production, a single bug can generate thousands of identical error logs. You need ways to handle that volume.
Grouping similar errors
Error tracking tools usually group errors using a fingerprint based on:
- Exception type.
- File and line where it occurred.
- Stack trace.
This means:
- You see "1 issue" with "10,000 events" instead of 10,000 separate issues.
- When you fix the bug, the issue stops receiving new events.
If you build your own system, you can approximate grouping with hashes of messages and key stack frames.
Throttling noisy errors
Sometimes an error explodes, for example if a database is down. You might want to:
- Log the first few errors in full.
- After that, log only summaries, for example "Database down, suppressed 1,000 similar errors in last 60 seconds".
Example idea in code:
from collections import defaultdict
import time
error_counts = defaultdict(lambda: {"count": 0, "last_reset": time.time()})
SUPPRESS_AFTER = 10
RESET_WINDOW = 60
def log_error_key(key: str, message: str):
now = time.time()
state = error_counts[key]
if now - state["last_reset"] > RESET_WINDOW:
state["count"] = 0
state["last_reset"] = now
state["count"] += 1
if state["count"] <= SUPPRESS_AFTER:
logger.error(message)
elif state["count"] == SUPPRESS_AFTER + 1:
logger.error("Suppressed further '%s' errors", key)You usually do not implement this manually for all errors, but the idea is useful for understanding how tooling manages noisy logs.
Error Logging in Background Jobs
Not all errors happen in HTTP requests. Many backends use background workers for tasks like sending emails or processing payments.
Important points:
- Errors in background jobs often do not have an immediate user-facing response.
- You must log them, or the failure can go unnoticed.
- Attach job-specific context, for example job name, task ID, payload details.
Example: logging errors in a worker
Pseudo code for a worker that runs tasks:
def run_task(task_name: str, payload: dict, task_id: str):
try:
TASKS[task_name](payload)
except Exception:
logger.exception(
"Error in background task",
extra={
"task_name": task_name,
"task_id": task_id,
}
)
# You might also mark task as failed in a database or retry itIf the worker is separate from your API process, ensure its logs also go to the centralized logging system.
Connecting Error Logs to Monitoring and Alerts
Error logs are not only for debugging after the fact. They are also a signal that something is wrong right now.
Turning error logs into signals
You can create alerts when:
- The rate of
ERRORlogs increases sharply. - A particular error appears for the first time in production.
- A
CRITICALerror occurs.
Example alert rules:
| Condition | Example alert |
|---|---|
| > 100 ERROR logs in 5 minutes | "High error rate in orders-api in production" |
| New error group appears | "New unhandled exception in checkout endpoint" |
| Any CRITICAL log in production | "Service outage or misconfiguration detected" |
These alerts often integrate with chat tools or incident management systems.
Making Error Logs Developer Friendly
Finally, error logs are for humans. Good error logging makes your future investigation easier.
Good practices
- Use clear messages:
"Failed to send email"is better than"Error occurred". - Include identifiers: order IDs, user IDs, job IDs, but not secrets.
- Avoid logging the same stack trace repeatedly manually: rely on centralized tools to aggregate.
- Follow a consistent pattern: similar format and fields for HTTP, background jobs, and scheduled tasks.
Compare:
Bad:
ERROR:root:Error
Traceback (most recent call last):
...Better:
ERROR:orders.checkout:Failed to charge card
user_id=42 order_id=987 path=/orders/987/charge
Traceback (most recent call last):
...
PaymentGatewayError: Connection timeoutThis tells you immediately:
- Which subsystem failed.
- Which user and order are affected.
- Likely where to start debugging.
Checklist
Use this quick checklist for error logging in a backend:
- Unhandled exceptions are caught and logged with stack traces.
- Logs are structured and include useful context.
- Sensitive data is masked or removed.
- 4xx and 5xx errors are logged with appropriate levels.
- Background jobs and workers log their failures.
- Logs from all instances go to a central system.
- Errors are grouped and not overwhelming.
- Alerts are configured based on error logs.
If you satisfy these points, your backend is much easier to maintain, debug, and operate 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!