24.4. Continuous Deployment
Table of Contents
Understanding Continuous Deployment
Continuous Deployment, often abbreviated as CD, is a way of working where every change that passes automated tests is automatically deployed to production without manual approval. It is the most automated and aggressive form of shipping software in the CI/CD family.
To understand Continuous Deployment clearly, it helps to contrast it with related concepts.
| Concept | Main Goal | Automatic deploy to production? | Human approval? |
|---|---|---|---|
| Continuous Integration | Integrate and test code changes frequently | No | Not applicable |
| Continuous Delivery | Keep code always ready to deploy | Optional, usually manual trigger | Yes, before production |
| Continuous Deployment | Deploy every good change to users automatically | Yes, after passing pipeline | No, except for emergencies/pause |
In this chapter, we focus on what is unique to Continuous Deployment, not CI in general or full pipeline design.
Key rule of Continuous Deployment
Every change that is:
- Merged into the main branch, and
- Successfully passes all automated checks in the pipeline,
must be automatically deployed to production, without additional manual steps.
If this is not true, you are not doing Continuous Deployment.
What Makes Continuous Deployment Different
In Continuous Delivery, you have an automated pipeline that builds, tests, and prepares an artifact, for example a Docker image. A human then decides when to deploy that artifact to production.
In Continuous Deployment, that last decision is moved into the pipeline itself. The pipeline decides, based only on automated checks, whether the new version goes live.
This has several important consequences:
- You must trust your tests and automation much more.
- You will deploy much more often, sometimes multiple times per day.
- You need strong safety nets in production, such as monitoring, rollbacks, and feature flags.
- You must keep changes small and incremental, because each one might be live very soon.
Continuous Deployment is not just a configuration change in your CI tool. It is a way of working that affects how you write code, design APIs, and operate your backend in production.
Typical Continuous Deployment Flow
A simple Continuous Deployment pipeline for a backend service often looks like this:
- Developer pushes or merges code into the main branch.
- CI pipeline starts:
- Fetches code.
- Installs dependencies.
- Builds the application or Docker image.
- Automated checks run:
- Static analysis and linting.
- Unit tests.
- Integration tests.
- API tests.
- Security checks, for example dependency scan.
- If all checks pass:
- The built artifact is tagged, for example Docker image
my-api:1.23.0. - The deployment job updates the production environment:
- For example, updates a Kubernetes Deployment.
- Or runs
docker-compose pull && docker-compose up -d. - The application is now live with the new version.
- Monitoring and alerting watch for problems after deployment.
If any step fails, the pipeline stops, and the old version continues to serve users.
Preconditions for Continuous Deployment
Before you enable Continuous Deployment, some conditions must be true, otherwise the risk will be too high.
Strong Automated Test Suite
You need tests that give you high confidence that a change is safe enough for production.
Minimum practical set:
- Unit tests for business logic.
- Integration tests that touch the database and external services (with test doubles when needed).
- API tests for main endpoints, both success and failure cases.
- Smoke tests that quickly check if the service is usable at all.
If your tests are weak, Continuous Deployment will only ship broken code faster.
Fast Pipeline
The pipeline must complete quickly. If a deployment takes 40 minutes, developers stop getting fast feedback and deployments pile up.
As a rough guide:
- Unit tests: seconds.
- Integration tests: a few minutes.
- Full pipeline to production: within 10 to 15 minutes for a small or medium backend.
You may need to:
- Run tests in parallel.
- Cache dependencies.
- Avoid heavy work on every run, for example rebuilding huge Docker layers unnecessarily.
Reliable Infrastructure as Code
Your deployment process should be described in code and version controlled, for example:
- Kubernetes manifests.
- Docker Compose files.
- Terraform scripts.
- CI configuration files, for example
.github/workflows/*.yml.
This reduces manual steps and makes deployment behavior reproducible.
Strong Observability
Since changes go to production automatically, you must be able to see quickly when something goes wrong.
You need at least:
- Application logs with useful context.
- Metrics, for example request rate, latency, error rates.
- Health checks for the service.
- Alerts when error rates or response times cross thresholds.
These topics are covered in more detail in other chapters, but they are essential for Continuous Deployment to be safe.
Example: Simple Continuous Deployment With GitHub Actions
Consider a small FastAPI backend deployed as a Docker container to a server that runs Docker Compose.
A simplified GitHub Actions workflow might look like this:
name: cd-to-production
on:
push:
branches:
- main
jobs:
build-and-test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- name: Install dependencies
run: |
pip install -r requirements.txt
pip install -r requirements-dev.txt
- name: Run tests
run: pytest
- name: Build Docker image
run: docker build -t my-api:${{ github.sha }} .
- name: Push Docker image
run: |
echo "$REGISTRY_PASSWORD" | docker login -u "$REGISTRY_USER" --password-stdin my-registry.example.com
docker tag my-api:${{ github.sha }} my-registry.example.com/my-api:${{ github.sha }}
docker push my-registry.example.com/my-api:${{ github.sha }}
deploy:
needs: build-and-test
runs-on: ubuntu-latest
steps:
- name: Deploy to production
uses: appleboy/ssh-action@v1.0.0
with:
host: ${{ secrets.PROD_HOST }}
username: ${{ secrets.PROD_USER }}
key: ${{ secrets.PROD_SSH_KEY }}
script: |
docker login my-registry.example.com -u "$REGISTRY_USER" -p "$REGISTRY_PASSWORD"
cd /srv/my-api
export IMAGE_TAG=${{ github.sha }}
docker-compose pull api
docker-compose up -d apiCharacteristics that make this Continuous Deployment:
- It triggers on every push to
main. - It runs tests automatically.
- If tests pass, it deploys automatically to production.
- There is no manual approval step.
You can later extend this with more checks, for example integration tests or security scans.
Safety Nets for Continuous Deployment
Because production can change frequently, you need ways to reduce the impact of bad changes.
Blue-Green and Rolling Deployments
These deployment strategies reduce downtime and make it easier to roll back.
- Blue-green: You have two environments, blue and green. You deploy to the idle one, run checks, then switch traffic over. If there is a problem you switch back.
- Rolling: You gradually update instances one by one. At any time some instances still run the old version, so the system keeps serving requests.
Most modern orchestrators such as Kubernetes support rolling deployments by default.
Feature Flags
Feature flags let you control which features are active without deploying new code.
For example:
- Code for a new payment method is merged and deployed behind a feature flag.
- By default, the flag is off, so the feature is not visible.
- You can enable the flag for a small percentage of users or internal testers.
- If a problem arises, you simply turn the flag off, without rolling back the entire deployment.
Feature flags make it easier to keep changes small and merge early, even if the feature is not fully ready for all users.
Fast Rollback
You must be able to revert a bad deployment quickly.
Common rollback methods:
- Redeploy a previous Docker image tag.
- Roll back a Kubernetes Deployment to a previous ReplicaSet.
- Use infrastructure as code to apply a previous configuration version.
A rollback should be a simple, documented command, not a manual procedure that you invent during an incident.
Rollback rule
If a production deployment causes significant errors or incidents,
prefer an immediate rollback over trying to debug live in production.
After rollback, you can debug using logs, staging environments, or canary releases.
Staging vs Direct-to-Production
Some teams deploy directly from the main branch to production. Others deploy first to a staging environment, then automatically to production after extra checks.
Options:
- Direct Continuous Deployment:
- Pros: Very fast feedback, simple flow.
- Cons: Higher risk, depends heavily on test quality.
- Staged Continuous Deployment:
- Automatic deploy to staging after tests.
- Additional automated checks in staging, for example smoke tests, synthetic traffic.
- If staging looks healthy, automatically deploy to production.
- Pros: Extra safety, can run heavier tests.
- Cons: More infrastructure to manage, slightly slower.
A pipeline with staging might use jobs like:
build-and-test→deploy-to-staging→smoke-test-staging→deploy-to-production.
The key is that the full chain is still automatic, with no manual approval.
Managing Risk With Small and Frequent Changes
Continuous Deployment works best when changes are:
- Small in scope.
- Well isolated.
- Easy to understand.
For example:
- Add a new field to the API response and make sure clients tolerate unknown fields.
- Add a new optional database column in one deploy.
- Start writing to the new column while still reading from the old one.
- In a later deploy, migrate data and switch reads to the new column.
This multi-step approach is called an expand and contract pattern and is very compatible with Continuous Deployment.
In contrast, big bang changes, for example completely rewriting a core API, are hard to ship safely with Continuous Deployment.
Common Pitfalls in Continuous Deployment
Some problems show up often when teams move to Continuous Deployment.
Flaky Tests
A flaky test sometimes passes and sometimes fails, even when the code did not change.
Effects:
- Random pipeline failures.
- Developers lose trust in the pipeline.
- People start rerunning jobs until they pass, which hides real problems.
Solutions:
- Quarantine flaky tests and fix them as a priority.
- Stabilize integration test environments.
- Avoid relying on external services during tests, use mocks or test doubles instead.
Slow Pipeline
If a pipeline takes too long, developers:
- Push less often.
- Accumulate large changes in one push.
- Disable tests to make it faster, which reduces safety.
You can:
- Run tests in parallel.
- Split tests into tiers, for example fast tests on every push, slow tests on a schedule or special trigger.
- Cache Docker layers and dependencies.
Manual Configuration Drift
If some configuration is changed manually on servers and not tracked in code, then:
- The same deployment behaves differently on different servers.
- It is harder to reproduce problems.
- Rollbacks might not fully restore the previous state.
Continuous Deployment works best when environments are created and configured from code.
When Continuous Deployment Makes Sense
Continuous Deployment is not required for every project, but it is very useful when:
- You are building a software as a service product.
- You want to deliver features and bug fixes quickly.
- You can invest in good automated tests and observability.
- You can structure work into small, incremental changes.
It may not be ideal when:
- Every release requires legal, compliance, or manual review, for example some medical or financial systems.
- You have extremely long manual test cycles that cannot be automated.
- The cost of a mistake is extremely high and you do not yet have strong safety mechanisms.
You can still automate everything up to a certain point and keep a manual approval step in such cases, which is Continuous Delivery rather than Continuous Deployment.
Summary
Continuous Deployment automatically ships every change that passes your pipeline to production. To make this safe, you need:
- Strong automated tests and fast pipelines.
- Reliable infrastructure as code.
- Observability, monitoring, and alerts.
- Safe deployment strategies and quick rollbacks.
- Small, incremental changes and feature flags.
For backend developers, understanding Continuous Deployment helps you design services that are easier to deploy, monitor, and operate at high speed while keeping risk under control.
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!