23.9. Backups
Table of Contents
Why Backups Matter in Backend Systems
Backups are your safety net. No matter how well you design and secure your backend, things will eventually go wrong: disks fail, developers run the wrong script, a migration goes bad, or data gets corrupted.
A backup is a copy of your data, configuration, or system state that you can restore later if you lose or damage the original.
A backend with no reliable backups is a backend that is guaranteed to lose data sooner or later.
For production backends, you should treat backups as a core part of deployment, not as an optional extra.
Common situations where backups save you:
- Hardware failure on the database server
- Accidental
DELETEorDROP TABLE - Buggy deployment or migration corrupts data
- Ransomware or malicious deletion
- Cloud region outage or account problems
Your goal is not only to create backups, but to ensure you can restore from them quickly, reliably, and to the right point in time.
What You Need to Back Up
In a typical backend deployment you usually care about more than just the database.
Core backup targets
| Target | Why it matters |
|---|---|
| Database (PostgreSQL, etc.) | Main source of truth for business data |
| Object storage (S3, etc.) | User uploads, reports, exported files |
| Configuration & secrets | How the app runs, connects, and authenticates |
| Application data that is not in DB | Caches you want to persist, job queues (sometimes) |
| Infrastructure config (IaC, scripts) | How to rebuild the environment |
You normally do not need to back up:
- Docker images (can be rebuilt from Dockerfiles)
- Application source code (already in Git)
- Ephemeral caches (Redis used as cache only)
Focus on data that is unique and cannot be recreated.
Types of Backups
There are a few common backup types. Choosing between them is a tradeoff between storage cost, backup time, and restore time.
Full, incremental, and differential backups
| Type | What it stores | Pros | Cons |
|---|---|---|---|
| Full | Complete copy of all data | Simple, fastest restore | Large, slow to create, costly storage |
| Incremental | Changes since the last backup of any type | Small, fast to create, saves space | Restore can require many backup files |
| Differential | Changes since the last full backup | Faster restore than incremental | Grows larger until next full backup |
Typical approach:
- Daily incremental backups
- Weekly full backups
This balance keeps restore steps manageable and storage costs reasonable.
Logical vs physical backups (databases)
For databases like PostgreSQL there are two conceptual approaches.
Logical backups
Export SQL or data representation:
- PostgreSQL example:
pg_dumpandpg_restore - Often produce
.sqlor custom dump formats
Pros:
- Can restore to different versions or servers
- Human-inspectable (to some degree)
- Good for schema and data migrations
Cons:
- Slower for very large databases
- Restores can take a long time
Physical backups
Copy the actual database files or use filesystem-level snapshots or tools like pg_basebackup.
Pros:
- Faster for large databases
- Better for full cluster recovery
- Supports point-in-time recovery together with WAL logs
Cons:
- Tied to engine version and configuration
- Harder to inspect
- Usually more complex to set up correctly
In small to medium projects, logical backups are often enough. As your database grows, you will likely combine physical backups with WAL archiving or cloud-native backups.
Backup Strategy: RPO and RTO
Before picking tools, define how much data loss is acceptable and how quickly you must recover.
RPO: Recovery Point Objective
RPO is the maximum acceptable amount of data you can afford to lose, usually measured in time.
Examples:
- RPO = 24 hours: Losing 1 day of data is acceptable
- RPO = 5 minutes: You can only lose a few minutes of data
RPO tells you how often you must back up or replicate data.
RTO: Recovery Time Objective
RTO is the maximum acceptable time your system can be down before being restored.
Examples:
- RTO = 4 hours: You can be offline for up to 4 hours
- RTO = 5 minutes: You need very fast failover or restore
RTO tells you how fast your recovery process must be.
Design your backup and restore process to satisfy both RPO and RTO. A backup that takes 24 hours to restore is useless if your RTO is 1 hour.
The 3-2-1 Backup Rule
A classic and very practical rule for production backups is the 3-2-1 rule:
3-2-1 rule
- Keep 3 copies of your data
- On 2 different types of storage
- With 1 copy offsite
Concretely, for a hosted backend:
- Copy 1: Production database itself
- Copy 2: Automatic database snapshot in the same cloud region
- Copy 3: Encrypted backup stored in another region or another provider
Storage types might differ by:
- Block storage vs object storage
- Different cloud providers
- On-premises vs cloud
The goal is to avoid losing all copies due to a single incident such as region failure or provider issue.
Database Backups in Practice
Most backends depend heavily on a relational database. Here is how to think about backing it up in a real deployment.
Scheduling database backups
At minimum:
- Nightly full logical dump (for small to medium databases)
- Frequent incrementals or WAL archiving if you need lower RPO
Examples of schedules:
| Scenario | Full backup | Incremental / logs |
|---|---|---|
| Small hobby project | Daily full | None |
| Small production app | Daily full | WAL or hourly incremental |
| High-traffic production system | Weekly full | Continuous WAL archiving |
Example: PostgreSQL logical backup
A simple script on a Linux server:
#!/usr/bin/env bash
set -e
# Configuration
DB_NAME="myapp"
DB_USER="backup_user"
BACKUP_DIR="/var/backups/postgres"
DATE=$(date +"%Y-%m-%d_%H-%M")
FILE="$BACKUP_DIR/${DB_NAME}_${DATE}.dump"
mkdir -p "$BACKUP_DIR"
pg_dump \
--format=custom \
--file="$FILE" \
--username="$DB_USER" \
"$DB_NAME"
# Optional: compress further or upload to object storage
gzip "$FILE"
Then schedule with cron:
0 3 * * * /usr/local/bin/backup_postgres.sh >> /var/log/backup_postgres.log 2>&1This creates one compressed backup per night at 03:00.
Testing database restore
A backup is only useful if you can restore it. Always test the full process.
Example for PostgreSQL:
createdb restore_test
pg_restore --dbname=restore_test --clean /path/to/backup.dumpCheck:
- Can you connect to
restore_test? - Are tables and data present?
- Does the schema look correct?
Make this test part of a regular operations checklist.
Application and Configuration Backups
Even if your application code is in Git, your running system includes more:
- Environment configuration
- Secrets
- Infrastructure definitions
Configuration
Configuration often comes from:
.envfiles- Kubernetes manifests or Helm charts
- Terraform or other IaC files
- Nginx or reverse proxy configs
Best practice:
- Store configuration as code in Git
- Encrypt sensitive parts when appropriate (for example using a secret manager or Git crypt)
- Back up the Git repository through your Git hosting provider or separate mirrors
Secrets
Secrets include:
- Database passwords
- API tokens
- Encryption keys
- JWT signing keys
Do not store secrets unencrypted in backups.
Typical approach:
- Use a secret manager (AWS Secrets Manager, HashiCorp Vault, etc.)
- Back up the secret manager itself or rely on provider’s durability
- For self-hosted Vault, back up its storage backend and unseal keys securely
If you must include secrets in backups:
- Encrypt the backup file with strong encryption (for example
gpgor provider-managed key encryption) - Store encryption keys separately from the backups
File and Object Storage Backups
User-uploaded files and generated assets are often stored in:
- Local filesystem on the server
- Network storage
- Object storage like S3 or compatible services
Local filesystem backups
If your uploads live on the server disk (for example /var/www/uploads):
- Use tools like
rsync,tar, orborgbackupto copy to another disk or to remote storage - Schedule backups with
cron - Consider using snapshots if your disk supports it (for example LVM or ZFS)
Typical script with tar:
#!/usr/bin/env bash
set -e
SRC="/var/www/uploads"
DEST="/backups/uploads_$(date +'%Y-%m-%d').tar.gz"
tar -czf "$DEST" "$SRC"Object storage backups
S3 and compatible services are durable, but you may still want:
- Versioning, to recover from accidental overwrite
- Replication to another region
- Backups to another provider
Useful strategies:
- Enable bucket versioning for critical buckets
- Enable cross-region replication
- Periodically sync to another provider using tools like
rcloneoraws s3 sync
Example with AWS CLI:
aws s3 sync s3://myapp-uploads s3://myapp-uploads-backup --storage-class STANDARD_IABackup Storage: Where to Keep Backups
Choosing backup storage affects cost, durability, and security.
Options
| Storage type | Pros | Cons |
|---|---|---|
| Same server disk | Fast, simple | Lost if server fails |
| Separate disk on same server | Handles disk failure | Not safe against server loss |
| Network-attached storage | Can be resilient, shared | Complexity, cost |
| Cloud object storage (S3, etc.) | Durable, cheap at scale | Requires careful security |
| Another cloud/provider | Protects against provider-wide issues | More complexity |
| Offline storage (cold backups) | Protects against online attacks | Hard to automate, slow restore |
A common practical pattern:
- Write backup to a local temporary file
- Upload it to object storage in the same cloud
- Replicate or sync to another region or provider
Backup Retention Policies
You do not want to keep every backup forever.
A retention policy defines how long you keep each backup.
Example policy:
- Keep daily backups for 7 days
- Keep weekly backups for 4 weeks
- Keep monthly backups for 12 months
This is sometimes called a backup rotation scheme.
You can implement retention:
- In your backup script, deleting old files after upload
- Using lifecycle rules in object storage (for example S3 Lifecycle)
Example with S3 lifecycle:
- Rule 1: Delete objects with prefix
daily/after 7 days - Rule 2: Delete objects with prefix
weekly/after 30 days
Make sure your retention supports:
- Compliance or legal requirements, if any
- Your need to debug old issues
Security of Backups
Backups often contain everything. If someone gains access to your backup, they may get:
- All user data
- All secrets and passwords
- All business information
So backups need at least as much protection as production data, often more.
Encrypt backups
Encrypt backups at rest:
- Use provider-managed encryption (for example S3 SSE-KMS)
- Or encrypt manually using tools such as
gpgoropenssl
Example using gpg:
tar -czf db_backup.tar.gz db_backup.dump
gpg --encrypt --recipient backup@mycompany.com db_backup.tar.gzKeep private keys in a secure place (for example a hardware token or secret manager).
Restrict access
Follow least privilege:
- Only specific backup or ops accounts can read/write backups
- Disallow public access to backup buckets
- Log access and periodically review
Protect against ransomware and malicious deletion
Consider:
- Immutable backups (write-once, read-many) for a certain period
- Separate accounts for backup storage, with minimal write permissions from production
Some object storage services support object lock or worm mode to prevent deletion before a set time.
Automating and Monitoring Backups
Manual backups will be forgotten. Production backups must be:
- Automated
- Monitored
- Reported
Automation
Use:
- Cron jobs on servers
- CI/CD pipelines for some backup tasks
- Managed backup features from your database or cloud provider
Example cron entry for a nightly backup:
0 2 * * * /usr/local/bin/backup_database.shMonitoring
You should know immediately when backups fail.
Typical monitoring:
- Backup script exits with non-zero status on failure
- Logs go to central logging system
- Alert if:
- No backup file appears in the expected location
- Backup size is suspiciously small or large
- Backup job fails or exceeds time limit
You can integrate with:
- Prometheus metrics and alerts
- Hosted monitoring services
- Email or Slack notifications from backup scripts
Disaster Recovery and Restore Procedures
Backups are only half of the story. Disaster recovery is the full plan to bring your system back.
Define recovery procedures
Document step by step:
- Where to find the latest valid backup
- How to provision or choose a target server or database
- How to restore:
- Database
- Files or object storage
- Configuration and secrets
- How to verify the restored system
- How to point traffic (DNS, load balancer) to the restored system
Example: Database disaster recovery checklist
- Spin up a new database instance
- Download the latest backup from object storage
- Restore with
pg_restoreor equivalent - Apply any necessary schema migrations that are not in the backup
- Update application configuration to point to new database
- Run smoke tests or health checks
- Enable traffic
Practice disaster recovery
Do regular drills:
- Quarterly or at set intervals
- Use backups to restore to a staging environment
- Measure:
- Actual RTO (how long it took)
- Whether RPO requirements were met
This also helps you discover:
- Missing documentation
- Broken backup scripts
- Privilege or access issues
Backups in Containerized and Cloud-native Environments
With Docker and orchestrators like Kubernetes, the running containers are usually ephemeral. Backups focus on persisted data.
Docker and volumes
When using Docker:
- Do not store critical data inside the container’s filesystem
- Use volumes or bind mounts
- Back up the volume content on the host or via volume plugins
Example pattern:
- PostgreSQL data lives in a Docker volume
pgdata - On the host,
pgdatais mapped to/var/lib/docker/volumes/pgdata/_data - Backup script reads from that host path or uses
pg_dumpfrom a container that can access the database
Kubernetes and cloud services
For Kubernetes:
- PersistentVolumes are backed by cloud disks
- Use:
- Database-as-a-Service with built-in backups (for example RDS, Cloud SQL)
- Or tools like Velero to back up PersistentVolumes and cluster state
For cloud-managed databases and object storage:
- Use the provider’s automatic backup and snapshot features
- Understand:
- Retention periods
- Point-in-time restore capabilities
- Region replication options
Cloud-native backups do not remove the need for testing restores.
Integrating Backups into Your Deployment Process
Since this chapter sits in the Deployment section, tie backups into how you ship and run your app:
- When you deploy a schema migration, ensure you have:
- A recent database backup
- A rollback plan if the migration fails
- When you change infrastructure (for example disk, database instance type), confirm backup and restore steps for the new setup
- When you scale to new regions, design region-specific backups
A simple rule for deployments that touch data:
Never apply irreversible database changes in production without a recent, tested backup and a clear restoration plan.
Even for smaller projects, a minimal practice is:
- Nightly database backup
- Weekly restore test to a separate environment
- Version-controlled infrastructure and configuration
This discipline makes your backend significantly more resilient and trustworthy.
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!