20.3. Structured Logging
Table of Contents
Why Structured Logging Matters
Traditional logs are often just plain text lines. They look readable to humans, but they are hard for tools to search, filter, and analyze in a reliable way.
Structured logging means that each log entry has a clear machine readable structure, usually as key value pairs, most commonly JSON. This makes your logs much more useful in real applications.
Some examples of where structure helps:
- Searching all logs for a specific
user_id - Grouping requests by
request_idto debug a single transaction - Building dashboards for counts of errors by
serviceorendpoint - Parsing logs into systems like Elasticsearch or Loki without brittle text parsing
Key idea: Structured logging turns every log entry into data, not just text.
In backend systems that run across multiple instances and services, structured logging is not optional. It is the only realistic way to make sense of large volumes of logs.
Unstructured vs Structured Logs
Let us compare a simple example.
Unstructured log
[2026-08-01 10:15:23] ERROR: Failed to create order for user 42: stock not available
To a human this is clear. To a machine, it is just one long string. If you want to find all logs for user 42, you must do a text search for user 42 and hope that the format never changes.
Structured log
The same event as JSON:
{
"timestamp": "2026-08-01T10:15:23.456Z",
"level": "ERROR",
"message": "Failed to create order: stock not available",
"user_id": 42,
"order_id": null,
"product_id": "P-123",
"stock_available": 0,
"service": "orders",
"endpoint": "POST /orders"
}Now a log system can:
- Filter by
"user_id": 42 - Show only
"service": "orders"logs - Build a chart of count of
"level": "ERROR"over time
Side by side comparison
| Aspect | Unstructured text | Structured log (JSON) |
|---|---|---|
| Human readability | Good | Good (if formatted) |
| Machine parsing | Hard, fragile | Easy, reliable |
| Field evolution | Breaks parsers | Add new keys without breaking old ones |
| Searching | Full text search only | Filter by fields, combine with conditions |
| Analytics | Limited, manual | Rich, can aggregate by fields |
Rule: Prefer structured logs for any backend that might need centralized logging, search, or metrics.
Log Fields and Context
The power of structured logs comes from consistent fields. You still have a human readable message, but you add context as separate keys.
Common base fields
Most backends benefit from including these fields in every log entry:
| Field | Description | Example |
|---|---|---|
timestamp | When the event happened | 2026-08-01T10:15:23.456Z |
level | Severity (DEBUG, INFO, WARN, ERROR) | INFO |
message | Human readable description | User logged in |
service | Name of the service | auth-service |
env | Environment | prod, staging, dev |
hostname | Machine or container name | api-1, pod-xyz |
logger | Logger name / module | auth.handlers |
Request and user context
For web backends, add context for each incoming request and user:
| Field | Description | Example |
|---|---|---|
request_id | Unique id per request | req-8f2c5a... |
trace_id | Correlation id across services | trace-12ab... |
method | HTTP method | POST |
path | Request path | /orders |
route | Logical route name | POST /orders |
status_code | Response status | 201 |
duration_ms | Time taken to handle the request | 123.4 |
user_id | Authenticated user id | 42 |
ip | Client IP address | 203.0.113.10 |
user_agent | Client user agent | Mozilla/5.0 ... |
Example with request context:
{
"timestamp": "2026-08-01T10:16:01.111Z",
"level": "INFO",
"message": "Request completed",
"service": "orders",
"env": "prod",
"request_id": "req-01H7R9WFZ4W6C7HAXKD4",
"trace_id": "trace-7b8c123",
"method": "POST",
"path": "/orders",
"status_code": 201,
"duration_ms": 87.32,
"user_id": 42
}
Rule: Always add correlation fields like request_id or trace_id so you can follow a single request across many log lines and services.
Domain specific context
You should also add fields that make sense for your domain, for example:
- In an e commerce system:
order_id,product_id,cart_id - In a payments system:
payment_id,gateway,amount,currency - In an authentication system:
login_method,mfa_enabled
Example for a failed payment:
{
"timestamp": "2026-08-01T10:20:00.000Z",
"level": "ERROR",
"message": "Payment declined",
"service": "payments",
"env": "prod",
"user_id": 42,
"order_id": "ORD-1001",
"payment_id": "PAY-987",
"amount": 49.99,
"currency": "USD",
"gateway": "stripe",
"reason": "insufficient_funds",
"request_id": "req-01H7R9..."
}JSON Logging in Practice
Most modern backends log in JSON. The exact API depends on the language, but the pattern is always similar.
You will see two main shapes:
- Plain JSON per line
- JSON inside a wrapper format from the logging library
Example: simple Python JSON logs
A minimal pattern, not using any special libraries:
import json
import sys
from datetime import datetime, timezone
def log(level, message, **fields):
entry = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"level": level,
"message": message,
**fields,
}
sys.stdout.write(json.dumps(entry) + "\n")
sys.stdout.flush()
log("INFO", "User logged in", user_id=42, service="auth", env="dev")This produces:
{"timestamp": "2026-08-01T10:30:00.123456+00:00", "level": "INFO", "message": "User logged in", "user_id": 42, "service": "auth", "env": "dev"}Each line is a complete JSON object. Log collectors like Fluent Bit or Filebeat can easily parse it.
Logging frameworks with JSON formatters
In real applications you use a logging framework, but you configure it to output JSON.
High level steps are similar for any language:
- Configure a formatter that outputs JSON
- Attach that formatter to handlers (console, file, etc.)
- Log using regular methods, but pass extra fields as structured data
Pseudo code to show the concept:
logger.info(
"Created order",
extra={
"order_id": "ORD-1001",
"user_id": 42,
"amount": 49.99,
},
)
Your logging configuration then embeds those extra fields directly in the JSON.
One log event per line
A very important detail: keep one JSON object per line in your log output. This is often called JSON Lines or NDJSON.
Correct:
{"level": "INFO", "message": "a"}
{"level": "INFO", "message": "b"}
{"level": "ERROR", "message": "c"}Incorrect:
[
{"level": "INFO", "message": "a"},
{"level": "INFO", "message": "b"}
]Log systems almost always expect each line to be a full event.
Rule: Write exactly one JSON object per line. Do not pretty print JSON in logs in production.
Designing a Log Schema
A log schema is a convention for what fields appear in your logs and how they are named.
Why a schema matters
Without a schema, each team or developer invents their own field names:
user_id,userId,uid,userstatus,status_code,http_statusservice,app,application
This makes search and analysis painful.
With a schema:
- Everyone uses the same field names
- Dashboards and alerts can rely on them
- You can evolve the schema slowly and carefully
Basic schema example
You do not need something huge. Start simple. For a small backend you might define a schema like:
| Category | Fields |
|---|---|
| Core | timestamp, level, message |
| Environment / host | service, env, hostname, version |
| HTTP request | request_id, method, path, status_code, duration_ms, ip, user_agent |
| User / auth | user_id, session_id, auth_method |
| Error / exception | error_type, error_message, stack_trace |
You can then document this schema for your team.
Example log that fits the schema:
{
"timestamp": "2026-08-01T11:00:00.000Z",
"level": "ERROR",
"message": "Unhandled exception while processing request",
"service": "orders",
"env": "prod",
"hostname": "api-3",
"version": "1.4.0",
"request_id": "req-123",
"method": "POST",
"path": "/orders",
"status_code": 500,
"duration_ms": 102.7,
"ip": "203.0.113.5",
"user_agent": "Mozilla/5.0 ...",
"user_id": 42,
"error_type": "DatabaseError",
"error_message": "connection timeout",
"stack_trace": "Traceback (most recent call last): ..."
}Naming conventions
Simple rules keep things consistent:
- Use
snake_casefor field names:user_id,request_id - Use consistent suffixes:
_idfor identifiers:user_id,order_id_msfor durations in milliseconds:duration_ms_countfor counts:retry_count- Use clear types:
- Numbers for numeric fields, not strings
- Booleans for true/false
- ISO 8601 for timestamps, for example
2026-08-01T11:00:00.000Z
Rule: Design your log fields like you design a database schema, with consistent names and clear types.
Adding Context Without Repeating Yourself
It is common to have values that should appear in every log within a request, such as request_id, user_id, service, and env.
You do not want to manually add them to every log call:
logger.info("Something", extra={"request_id": request_id, "user_id": user_id, ...})Instead, use per request context.
Concept: logging context
The idea is:
- When a request starts, create a context that includes shared fields
- Any log inside the handling of that request automatically includes those fields
In different languages this has different names:
- Log context
- MDC (Mapped Diagnostic Context)
- Log scope
- Correlation context
Conceptually it behaves like:
with log_context(request_id="req-123", user_id=42):
logger.info("Started processing")
logger.info("Doing step 1")
logger.error("Something failed")
All three lines will receive request_id and user_id automatically in the JSON.
Example outputs for all three log lines:
{"level": "INFO", "message": "Started processing", "request_id": "req-123", "user_id": 42}
{"level": "INFO", "message": "Doing step 1", "request_id": "req-123", "user_id": 42}
{"level": "ERROR", "message": "Something failed", "request_id": "req-123", "user_id": 42}This pattern is essential in web backends, where a single request can trigger many log entries.
Logging Levels and Structured Data
Structured logging does not change the semantics of log levels, but it makes them easier to analyze.
Typical levels:
DEBUG: Detailed internal information, disabled in productionINFO: Normal operational messagesWARNINGorWARN: Something unexpected, but the system can continueERROR: Something failed, user may be affectedCRITICALorFATAL: System is unusable or near to failing entirely
With structured logs, you can:
- Alert on counts of
ERRORorCRITICALgrouped byservice - Count
WARNINGlogs that mention specificerror_typevalues - Track ratios of
ERRORlogs to total logs
Example, two error logs with different types:
{
"timestamp": "2026-08-01T11:10:00.000Z",
"level": "ERROR",
"message": "Database connection failed",
"service": "orders",
"error_type": "DatabaseError",
"retryable": true
}{
"timestamp": "2026-08-01T11:10:01.000Z",
"level": "ERROR",
"message": "User permission denied",
"service": "orders",
"error_type": "AuthorizationError",
"retryable": false,
"user_id": 42
}You can build alerts like:
- If
error_type = "DatabaseError"andretryable = truecount per minute exceeds 100, alert.
This becomes trivial with structured data.
Privacy and Security in Structured Logs
Structured logs are easy to search and export, which is very powerful but also risky.
You must be careful not to log sensitive information.
Examples of data you should avoid logging:
- Passwords or password hashes
- Full credit card numbers
- Full personal data like national ID numbers
- Authentication tokens, API keys, or session tokens
- Secrets from environment variables
Logs that break this rule are dangerous because:
- Logs are often stored in external systems
- Many people can access them
- Logs might be kept for a long time
- Logs may be copied into backups
Redacting fields
A common pattern is to define sensitive fields and redact them automatically.
Example of redaction:
Input data:
{
"email": "user@example.com",
"password": "super-secret",
"card_number": "4111111111111111"
}Redacted in logs:
{
"email": "user@example.com",
"password": "***REDACTED***",
"card_number": "***REDACTED***"
}You can apply redaction when:
- Serializing request bodies to logs
- Logging responses that might contain secrets
- Logging exception contexts
Rule: Never log secrets, passwords, or full payment data. If in doubt, do not log the value, or redact it.
Using Structured Logs in Aggregation Systems
In many production systems, your application logs to standard output. A separate agent collects these logs and sends them to a central place.
Examples of central systems:
- Elasticsearch, OpenSearch
- Loki
- Cloud specific services, for example CloudWatch, Stackdriver, Azure Monitor
Structured logging makes life easier:
- The collector only needs to parse JSON per line
- The central system automatically knows fields and types
- You can build saved queries and dashboards on fields
Example aggregation query
If your logs look like this:
{"timestamp": "...", "level": "ERROR", "service": "orders", "error_type": "DatabaseError"}
{"timestamp": "...", "level": "ERROR", "service": "orders", "error_type": "ValidationError"}
{"timestamp": "...", "level": "INFO", "service": "auth"}You can query:
- All errors from the orders service:
level = "ERROR" AND service = "orders"- Count of each
error_type: - Group by
error_typewhereservice = "orders" AND level = "ERROR"
You did not need special parsing logic. You just use the structured fields.
Practical Examples of Structured Log Entries
Here are several complete example entries to show realistic patterns.
Successful request log
{
"timestamp": "2026-08-01T11:30:00.000Z",
"level": "INFO",
"message": "Request completed",
"service": "orders",
"env": "prod",
"request_id": "req-abc123",
"trace_id": "trace-xyz789",
"method": "POST",
"path": "/orders",
"route": "POST /orders",
"status_code": 201,
"duration_ms": 95.3,
"user_id": 42,
"ip": "203.0.113.7"
}Business event log
{
"timestamp": "2026-08-01T11:31:00.000Z",
"level": "INFO",
"message": "Order created",
"service": "orders",
"env": "prod",
"request_id": "req-abc123",
"user_id": 42,
"order_id": "ORD-1005",
"amount": 89.00,
"currency": "USD",
"items_count": 3,
"payment_method": "credit_card"
}Background job log
{
"timestamp": "2026-08-01T11:32:00.000Z",
"level": "INFO",
"message": "Job executed",
"service": "worker",
"env": "prod",
"job_type": "send_email",
"job_id": "job-7788",
"attempt": 1,
"duration_ms": 210.5,
"status": "success",
"email_type": "order_confirmation",
"user_id": 42,
"order_id": "ORD-1005"
}Error with stack trace
{
"timestamp": "2026-08-01T11:33:00.000Z",
"level": "ERROR",
"message": "Failed to reserve stock",
"service": "inventory",
"env": "prod",
"request_id": "req-xyz555",
"order_id": "ORD-1006",
"product_id": "P-999",
"quantity": 2,
"error_type": "StockReservationError",
"error_message": "Not enough stock available",
"stack_trace": "Traceback (most recent call last): ...",
"retryable": false
}In all these examples, you can see that:
messageis still human friendly- Key details are available as separate fields
- Logs from different parts of the system share consistent field names
Summary
Structured logging treats logs as data, not just text. By logging in a consistent structured format, usually JSON, with predictable fields, you can:
- Search and filter logs reliably
- Correlate events using
request_idortrace_id - Build dashboards and alerts from log fields
- Share log formats across services and teams
To use structured logging effectively in backends:
- Decide on a simple log schema and naming conventions
- Include core fields in every entry, plus request and domain context
- Use one JSON object per line, with levels and timestamps
- Avoid logging secrets and sensitive data, or redact it
- Use logging context to avoid repeating shared fields
These practices make logging a powerful tool for understanding, debugging, and operating backend systems.
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!