24.3. Continuous Delivery
Table of Contents
Understanding Continuous Delivery
Continuous Delivery, usually shortened to CD, is a software engineering practice where your code is always in a deployable state and can be released to users at any time with a small, repeatable, low‑risk process.
You will often see CI/CD used together. Continuous Integration (CI) focuses on merging and testing code frequently. Continuous Delivery (CD) focuses on making that tested code ready for production release at all times.
Core idea of Continuous Delivery:
Every change that passes automated tests is automatically prepared for release to production, and releasing it is a business decision, not a technical challenge.
In backend development, this is especially important because servers, databases, and APIs must be updated safely without downtime or data loss.
Continuous Delivery vs Continuous Deployment
These two terms are close but not the same.
| Practice | What gets automated | Who decides to release? |
|---|---|---|
| Continuous Integration | Build and automated tests on each change | Developer merges when tests pass |
| Continuous Delivery | Build, test, package, and prepare for release | Human (team, product owner, SRE) |
| Continuous Deployment | Build, test, package, and auto release to prod | System releases automatically |
With Continuous Delivery:
- After code is merged to the main branch, the pipeline:
- runs tests,
- builds containers or artifacts,
- runs extra checks,
- deploys to staging,
- waits for a manual approval to deploy to production.
With Continuous Deployment:
- All the above happens and then the last step, deployment to production, is also automatic if everything passes.
Important distinction:
Continuous Delivery automates up to production and requires manual approval.
Continuous Deployment automates through production with no manual gate.
In this course, you will mostly focus on Continuous Delivery, because it is a safer and more common initial step for backend teams.
Why Continuous Delivery Matters for Backend Developers
For backend services, manual and infrequent releases often cause:
- Large batches of changes that are hard to debug.
- Long release windows and nighttime deployments.
- Rollbacks that are painful or impossible.
- Fear of releasing, which slows down development.
Continuous Delivery aims to solve this by:
- Releasing small changes frequently.
- Having repeatable, automated pipelines.
- Making releases boring and predictable.
Some concrete benefits:
- Faster feedback
You can deploy new backend endpoints or changes to staging quickly and test them with real clients or QA. - Reduced risk
Each deployment contains fewer changes. If something breaks, it is easier to find and fix. - Easier rollbacks
If each release is versioned and automated, rolling back often becomes a single command or button. - Better collaboration
Backend, frontend, QA, and product can all work against the same, frequently updated environments.
What Does “Always Deployable” Mean?
In Continuous Delivery, the main branch of your repository should always be:
- Green (all tests passing),
- Buildable (Docker images, binaries, or packages can be created),
- Deployable (can be rolled out without manual fixes).
This does not mean the application is perfect. It means that at any point, if the business asks for a release, you can:
- Take the current main commit.
- Trigger the release pipeline.
- Deploy to production safely.
Example in a Backend Context
Imagine a FastAPI application with a PostgreSQL database.
In a Continuous Delivery setup:
- Every merge to
main: - runs unit tests and API tests with pytest,
- builds a Docker image,
- runs database migrations against a test database,
- deploys the backend to a staging environment,
- runs smoke tests against staging (simple checks that the API is up and basic endpoints work).
If all steps pass, the pipeline marks this version as ready for production.
You might then:
- Review metrics or do manual exploratory testing on staging.
- Press an “Approve” button in your CI/CD platform to deploy the same version to production.
The Continuous Delivery Pipeline
A CD pipeline is a sequence of automated steps that move code from “just built” to “ready for production” and often beyond into “actually deployed”.
A typical backend Continuous Delivery pipeline might have these stages:
- Build
- Install dependencies.
- Run static checks (like linters or formatters).
- Build a Docker image of your backend.
- Test
- Run unit tests.
- Run integration tests with a real database (like PostgreSQL in Docker).
- Run API tests against the running backend.
- Package and Publish
- Tag the build (for example,
v1.4.3). - Push the Docker image to a container registry.
- Save artifacts like migration scripts or documentation.
- Deploy to Staging
- Deploy the new image to a staging environment.
- Apply database migrations on staging.
- Run smoke tests on staging (basic endpoints, health checks).
- Manual Approval
- Developer, QA, or product reviews staging.
- Someone clicks “approve” for production deployment.
- Deploy to Production
- Deploy the same image and configuration used in staging to production.
- Apply migrations (carefully, often with special strategies).
- Run health checks.
- Post‑Deployment Checks
- Monitor logs and metrics.
- If something goes wrong, roll back.
Simple Pipeline Flow
You can think of a Continuous Delivery pipeline as a function:
$$
\text{Pipeline}(commit) \rightarrow \text{deployable version}
$$
Where a deployable version includes:
- A built artifact (for example, Docker image),
- A version tag,
- All checks passing,
- A record of how to deploy it to environments.
Key Practices that Enable Continuous Delivery
You cannot just “turn on” Continuous Delivery. You need some practices in place.
Automated Testing
Without automated tests, you cannot safely rely on a pipeline to tell you if code is good enough.
In backend development you typically need:
- Unit tests for small pieces of logic.
- Integration tests that hit your database, caches, and message queues.
- API tests that call endpoints and verify responses.
- Smoke tests that check basic API functionality after deployment.
Rule:
If a bug is found after release, add or improve an automated test that would have caught it. Over time, your test suite becomes a safety net for Continuous Delivery.
Infrastructure as Code
Your environments should be created and updated via code:
- Docker Compose files,
- Kubernetes manifests,
- Terraform or similar tools,
- Ansible or shell scripts.
This makes environments:
- Repeatable (staging is similar to production),
- Versioned (you can see changes),
- Automated (no “secret manual steps”).
Configuration Management
Backend services often have environment-specific settings:
- Database URLs,
- API keys,
- Redis hosts,
- Feature flags.
In Continuous Delivery, configuration must be:
- Separated from code, for example via environment variables.
- Automated, so the pipeline can set these values for each environment.
You will cover this in more depth in the CI/CD and deployment chapters, but for CD it is essential.
Versioning and Artifacts
Every successful pipeline run should produce:
- An identifiable version, for example:
- Git commit hash, or
- Semantic version like
1.3.0, or - Combination like
1.3.0+build.42. - An artifact:
- Docker image pushed to a registry,
- Or a binary, or a package.
This lets you:
- Deploy exactly what passed tests.
- Roll back to a known good version.
Continuous Delivery Across Environments
You will often have multiple environments:
| Environment | Purpose | Who uses it |
|---|---|---|
| Dev | Developer playground, often local | Individual developers |
| Test | Run CI/CD tests, integration, performance | CI pipeline, QA |
| Staging | Production-like environment, final verification | QA, product, sometimes clients |
| Prod | Real users and real data | Customers, systems |
In Continuous Delivery, the goal is:
- Use the same build artifact (for example, the same Docker image) across test, staging, and production.
- Change only configuration and environment resources, not the code artifact.
Example: FastAPI Service Through Environments
- Code merged to
main. - CI builds
my-api:1.0.5Docker image, pushes it to a registry. - CI deploys
my-api:1.0.5to test and runs automated tests. - If successful, CI deploys
my-api:1.0.5to staging. - After manual approval, CI deploys the same image
my-api:1.0.5to production.
This is safer than rebuilding for every environment, because you avoid “it worked on staging but the production build is different”.
Release Strategies in Continuous Delivery
How you actually switch traffic to new backend versions is also part of Continuous Delivery.
Common strategies:
1. Rolling Updates
- Replace old instances of your backend with new ones gradually.
- Example in Kubernetes:
- Have 4 pods of version 1.
- Gradually start pods of version 2 and stop pods of version 1.
- If issues appear, stop and roll back.
2. Blue‑Green Deployments
- Maintain two identical production environments:
- Blue: currently serving traffic.
- Green: new version, not yet receiving traffic.
- Steps:
- Deploy new version to green.
- Run tests against green.
- Switch the load balancer to point from blue to green.
- If something goes wrong, switch back to blue.
3. Canary Releases
- Release the new version to a small percentage of traffic.
- Watch metrics and errors.
- If all is good, gradually increase the percentage.
These strategies reduce risk and integrate well with Continuous Delivery pipelines.
Database Changes in Continuous Delivery
Backend deployments often include database schema changes. Handling these safely is critical.
Some common practices:
- Database Migrations as Code
- Use tools like Alembic (for SQLAlchemy) to define migrations in version control.
- Migrations run automatically in the pipeline or as part of deployment.
- Backward Compatible Changes
- Try to make schema changes that work with both old and new code for some time.
- For example:
- Add a new column but do not remove the old one immediately.
- Deploy code that writes to both columns.
- Later deploy code that reads from the new column.
- Finally, remove the old column.
- Safe Rollbacks
- Consider what happens to data if you roll back the application but the database schema is newer.
- Sometimes you need rollback migrations or clear steps to fix data.
Rule for database changes:
Assume application and database may be on slightly different versions during deployment. Migrations must not break older or newer versions unexpectedly.
Example: A Simple Continuous Delivery Workflow
Here is a simplified Continuous Delivery pipeline for a FastAPI + PostgreSQL project using Docker and GitHub Actions. This is not full YAML, but it gives a sense of the flow.
- On merge to main:
1. Checkout code
2. Set up Python
3. Install dependencies
4. Run linters and formatters
5. Run unit tests
6. Build Docker image: my-api:${GIT_SHA}
7. Push Docker image to registry
8. Run integration tests using that image in Docker Compose (FastAPI + Postgres)
9. If all pass, deploy image to staging (for example via Docker Compose or Kubernetes)
10. Run smoke tests against staging (health endpoint, one main endpoint, etc.)
11. Mark build as "ready for production"- On manual approval for production:
1. Take same Docker image tag (my-api:${GIT_SHA})
2. Update production environment to use this image
3. Run database migrations
4. Run health checks
5. Notify team of deploymentNo code changes happen between staging and production. Only configuration (like database URLs and secrets) differ.
Team Practices Around Continuous Delivery
Technology is only part of Continuous Delivery. Team habits matter a lot.
Helpful practices:
- Trunk‑based development
- Developers merge small changes to
mainfrequently. - Feature branches are short‑lived.
- Avoid long‑running branches that diverge.
- Small, incremental changes
- Avoid huge PRs that are hard to review and test.
- Break features into small backend changes that can be deployed safely.
- Feature flags
- Use configuration switches to turn features on or off.
- You can deploy code for a feature that is disabled in production, then enable it later.
- Strict pipeline rules
- If the pipeline is red (failing), fix it before adding new changes.
- Do not bypass tests or manual approvals except in emergencies.
- Monitoring and observability
- After each deployment, you should have:
- Logs to inspect errors,
- Metrics (like response times, error rate),
- Health checks for services.
Challenges and How to Handle Them
Continuous Delivery is powerful but not trivial.
Typical challenges:
| Challenge | Mitigation idea |
|---|---|
| Flaky tests | Stabilize tests, isolate side effects, use fixed test data |
| Long pipelines | Parallelize steps, optimize Docker builds and test suites |
| Complex manual steps | Script and automate them, use Infrastructure as Code |
| Risky database changes | Use incremental migrations, test thoroughly in staging |
| Resistance to frequent deployments | Start with non‑critical services, show reliability improvements |
It is normal for a team to adopt Continuous Delivery gradually. You do not need perfection to start gaining value. Even automating build, tests, packaging, and staging deployment is already a big win.
How This Fits the Rest of the Course
In other parts of this course, you will:
- Use GitHub Actions or GitLab CI to build CI/CD pipelines.
- Dockerize your FastAPI backend and PostgreSQL database.
- Configure staging and production deployments.
- Add tests, logging, monitoring, and rollback strategies.
Continuous Delivery is the conceptual goal that explains why we set up pipelines in a particular way. It is about ensuring that your backend can be released safely and quickly whenever needed.
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!