24.5. CI/CD Pipelines
Table of Contents
Understanding CI/CD Pipelines
A CI/CD pipeline is the automated path that your code follows from a Git commit to running in a real environment. Instead of doing steps manually, you describe them once, and a pipeline runs them in the same way every time.
This chapter focuses on what a CI/CD pipeline is, what typical stages look like, and how it fits into backend development. The next chapters will show concrete examples with GitHub Actions and GitLab CI/CD.
What Is a CI/CD Pipeline?
A CI/CD pipeline is a series of automated steps that run whenever code changes. These steps usually include:
- Fetching the latest code
- Installing dependencies and tools
- Running tests and quality checks
- Building artifacts, for example Docker images
- Deploying to an environment, such as staging or production
You define these steps in a configuration file, usually in YAML, stored in the same repository as your code.
Key idea: A CI/CD pipeline is code that automates how you build, test, and deploy your application. If you cannot run it with one command or one button, it is not a proper pipeline.
Basic Structure of a Pipeline
Most pipeline systems share the same core ideas:
- Jobs: Individual units of work, for example "run tests"
- Stages: Ordered groups of jobs, for example "test" stage, then "build" stage
- Triggers: Conditions when the pipeline should run, for example "on every push to main"
- Artifacts: Files produced by one job and used by another, for example test reports
- Environments: Places where you deploy, such as "staging" or "production"
A typical minimal pipeline has at least these stages:
- Checkout / setup
- Test
- Build
- Deploy
The exact names differ between tools, but the idea is the same.
Example: Conceptual Pipeline Flow
| Stage | Example job | Purpose |
|---|---|---|
| setup | Checkout repo, install Python | Prepare environment |
| test | Run unit and API tests | Prove code still works |
| build | Build Docker image | Create deployable package |
| deploy | Deploy to staging or prod | Release new version of application |
For a backend project, your pipeline will usually at least run Python tests and build Docker images.
Triggers and Branch-Based Pipelines
You rarely want to run the same actions for every branch. For example, you might:
- Run tests for all branches and pull requests.
- Build and deploy to staging when you push to
develop. - Deploy to production only when you push a tag or merge to
main.
Typical triggers include:
- On push: Run when someone pushes commits.
- On pull request / merge request: Run before merging to validate changes.
- On tag: Run for versioned releases, for example
v1.2.0. - On schedule: Run nightly jobs, for example full test suite, security scans.
In your config file you usually describe something like:
- "Run test jobs on every push"
- "Run deploy jobs only on main branch and only when the tests have passed"
This is how pipelines enforce safe workflows.
Common Pipeline Stages for Backend Projects
1. Checkout and Setup Stage
This stage prepares everything other stages need.
Typical steps:
- Check out the repository from Git
- Set Python version, for example 3.11
- Install dependencies with
pip install -r requirements.txt - Set environment variables, such as
ENV=cior database URLs
Example (conceptual, tool-agnostic):
- stage: setup
jobs:
- name: setup-python
steps:
- checkout-code
- install-python: "3.11"
- pip-install: "requirements.txt"The exact syntax differs between tools, but the meaning is the same: get code, install Python, install packages.
2. Test Stage
This is the core of Continuous Integration. The goal is to reject broken changes automatically.
Typical jobs:
- Run unit tests with
pytest - Run integration tests, sometimes with temporary databases and services
- Collect coverage
- Optionally, run static checks like
flake8ormypy
Many teams separate "tests" into multiple jobs for speed and clarity.
Example layout:
| Job | Command example | Purpose |
|---|---|---|
| unit-tests | pytest tests/unit | Fast feedback |
| integration | pytest tests/integration | DB, Redis, external systems |
| style-check | flake8 app | Code style |
| type-check | mypy app | Type safety |
A pipeline can run these jobs in parallel within the same stage. The stage is successful only if all jobs succeed.
Rule: A pipeline must fail fast when any test fails. Do not allow broken tests to "pass" or be ignored. If tests are flaky, fix them, do not just rerun manually.
3. Build Stage
Once your code passes tests, you create something that can be deployed. For backend applications this is often:
- A Docker image that contains your code and dependencies
- A Python package, for example
.whlor.tar.gz, if you are publishing a library
In Docker-based backend projects, a common pattern is:
- Build a Docker image using your
Dockerfile. - Tag it with the commit SHA and/or a version.
- Push it to a container registry, for example GitHub Container Registry or Docker Hub.
Conceptual example:
- stage: build
needs: [test] # only run if tests passed
jobs:
- name: build-and-push-image
steps:
- docker-build: "my-api:${COMMIT_SHA}"
- docker-push: "registry.example.com/my-api:${COMMIT_SHA}"The important part is the dependency: the build stage must not run if tests fail.
4. Deploy Stage
The deploy stage uses the artifact from the build stage to update a real environment.
Common patterns:
- Deploy to a staging environment on every push to a development branch.
- Deploy to production only on approved merges or tags.
For Docker-based deployments, a deploy job might:
- Pull the new image from the registry.
- Run
docker-compose pull && docker-compose up -d. - Run database migrations, for example
alembic upgrade head.
Pipeline systems usually allow:
- Manual approvals for deploy jobs, so someone must click a button before deploying to production.
- Environment protection, so only specific people can deploy to production.
Rule: Never deploy directly from a developer machine to production. Always deploy from a CI/CD pipeline using a versioned artifact that has passed tests.
Parallelism and Dependencies
Pipelines are often represented as graphs. Jobs can run:
- In parallel when they are independent, for example "lint" and "test".
- Sequentially when one depends on the output of another, for example "build" after "test".
For example:
lintandunit-testsrun in parallel.integration-testsdepend onunit-tests.builddepends on all tests.deploydepends onbuild.
Visual idea:
- Stage
test lintunit-testsintegration-tests(needsunit-tests)- Stage
build build-docker(needslint,unit-tests,integration-tests)- Stage
deploy deploy-staging(needsbuild-docker)
This structure gives fast feedback, since simple checks finish quickly and can fail the pipeline before slower jobs even start.
Artifacts and Caching
Pipelines often run on clean, temporary machines. They start from zero each time. Two concepts help avoid repeated work:
Artifacts
Artifacts are files produced by one job and passed to others. Examples:
- Coverage reports
- HTML test reports
- Compiled assets
- Build outputs
For example, an integration-tests job might upload a test report as an artifact, then a later "collect-reports" job could combine them or publish them as a web page.
Caches
Caches speed up repeated work, such as:
- Python dependencies in a
venvor~/.cache/pip - Node modules for frontend builds in full-stack repos
You usually configure the cache key using the requirements.txt checksum and possibly the Python version. If the dependencies file has not changed, the pipeline can reuse cached dependencies.
Rule: Use artifacts for results that must be exact and tracked, like build outputs, and caches only for things that can be safely regenerated, like dependencies.
Environments and Promotion
A key practice in CI/CD is promoting the same artifact through multiple environments.
Common environments:
- Dev: Where developers or feature branches deploy frequently for quick checks.
- Staging: Production-like environment used for final testing.
- Production: Real users.
Instead of rebuilding for each environment, you:
- Build one Docker image in the pipeline.
- Test it.
- Deploy the same image to staging.
- If staging is good, deploy exactly the same image to production.
This avoids "works in staging but not in prod" due to different builds or dependency versions.
Typical pipeline design:
- On push to
develop: run tests, build image, deploy to staging. - On tag
vX.Y.Z: re-use the existing image or build once, then deploy to production after manual approval.
Manual vs Automatic Steps
Not every pipeline step must be fully automatic.
Common patterns:
- Automatic:
- Run tests on every push.
- Build artifacts when tests pass.
- Deploy to dev or staging on specific branches.
- Manual:
- Approve deployment to production.
- Run database migrations that need human coordination.
- Roll back to a previous version.
Most CI/CD systems let you mark a job as "manual" or "requires approval" and still keep it part of the pipeline graph.
Handling Secrets in Pipelines
Pipelines usually need secrets:
- Database passwords
- API keys (for cloud providers, registries, email services)
- JWT signing keys
You must never put them in your repository.
Common approaches:
- Use the CI/CD platform's secret storage or "variables".
- Inject them into jobs as environment variables at runtime.
- Use limited-scope credentials:
- A registry token that can push images but not delete everything.
- A deploy key that can pull code but not push.
Example behavior:
- The build job uses
$REGISTRY_PASSWORDto login to the container registry. - The deploy job uses
$SSH_KEYto connect to the server. - None of these values appear in the repo or in logs.
Rule: Secrets must be stored securely by the CI/CD system and never committed to Git or printed in pipeline logs.
Designing a Simple Backend Pipeline
To tie everything together, here is a conceptual pipeline for a FastAPI + PostgreSQL project using Docker. The syntax is generic, but the flow can be implemented in GitHub Actions or GitLab CI/CD.
Stages:
testbuilddeploy_stagingdeploy_production
Jobs:
stages:
- test
- build
- deploy_staging
- deploy_production
jobs:
test:
stage: test
runs-on: linux
steps:
- checkout-code
- install-python: "3.11"
- pip-install: "requirements.txt"
- run: "pytest --maxfail=1 --disable-warnings -q"
build:
stage: build
needs: [test]
rules:
- if: branch in ["develop", "main"]
steps:
- checkout-code
- docker-login: "registry.example.com"
- docker-build: "registry.example.com/my-api:${COMMIT_SHA}"
- docker-push: "registry.example.com/my-api:${COMMIT_SHA}"
deploy-staging:
stage: deploy_staging
needs: [build]
rules:
- if: branch == "develop"
environment: "staging"
steps:
- ssh: "staging-server.example.com"
- run: |
docker pull registry.example.com/my-api:${COMMIT_SHA}
docker-compose up -d
deploy-production:
stage: deploy_production
needs: [build]
rules:
- if: tag matches "v*"
environment: "production"
when: manual
steps:
- ssh: "prod-server.example.com"
- run: |
docker pull registry.example.com/my-api:${COMMIT_SHA}
docker-compose up -dThis example is not tied to a specific CI/CD tool, but it shows how you can:
- Run tests first.
- Only build when tests pass.
- Deploy to staging automatically for development.
- Deploy to production from a tag, with a manual approval.
How CI/CD Pipelines Fit Into Your Backend Workflow
In a typical backend workflow:
- You create a branch, for example
feature/add-tasks-endpoint. - You commit and push changes.
- The CI pipeline runs tests and checks.
- You open a pull request.
- The pipeline runs again on the pull request.
- If everything is green, you merge to
developormain. - On merge, the CD part of the pipeline builds and possibly deploys.
- If a production deploy breaks something, you roll back using the pipeline, for example by redeploying a previous image.
The pipeline becomes a central part of your development process. Over time, you will add:
- More tests
- Security scans
- Database migration jobs
- Smoke tests after deploy
- Notifications to Slack or email on failures
Future chapters will show how to express these ideas in real CI/CD tools, specifically GitHub Actions and GitLab CI/CD.
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!