15.16. Dependency Vulnerabilities
Table of Contents
Understanding Dependency Vulnerabilities
When you build backend applications, you almost always depend on external libraries and frameworks. These dependencies save you time, but they also import other people's code and, with it, other people's bugs and security issues.
This chapter explains how dependency vulnerabilities appear, why they are dangerous for a backend, and how to manage them in practice.
What Are Dependencies?
A dependency is any external package, library, or framework that your project needs in order to run.
Common types of dependencies for a backend:
| Type | Example for Python backends |
|---|---|
| Web framework | FastAPI, Django, Flask |
| Database drivers | psycopg2, asyncpg, mysqlclient |
| ORMs | SQLAlchemy, Tortoise ORM |
| Utility libraries | requests, httpx, pydantic, python-jose |
| Background workers | celery, rq |
| Cloud SDKs | boto3, google-cloud-storage |
| Testing tools | pytest, faker |
Each dependency often has its own dependencies. This creates a dependency tree, also called the dependency graph.
Example requirements.txt:
fastapi==0.115.0
uvicorn[standard]==0.30.0
sqlalchemy==2.0.34
psycopg2-binary==2.9.9
python-jose[cryptography]==3.3.0
passlib[bcrypt]==1.7.4Installing these packages will pull in many more packages automatically. Any one of them can contain a vulnerability.
What Are Dependency Vulnerabilities?
A dependency vulnerability is a security weakness in one of the external packages you use. If your application uses a vulnerable version of a package, then your app is vulnerable too, even if your own code is perfect.
Typical examples:
- A HTTP client library that is vulnerable to SSRF (server-side request forgery)
- A JSON Web Token library that accepts invalid signatures
- A ZIP file parser that allows directory traversal (writing files outside the target directory)
- A templating engine that allows remote code execution when misused
A backend is only as secure as its weakest dependency version.
Even if the vulnerability is in a rarely used part of the library, an attacker may find a way to trigger it.
Sources of Dependency Vulnerabilities
- Coding mistakes in the library itself
For example, forgetting to validate input or incorrectly using cryptography primitives. - Unsafe defaults
A library may ship with insecure default configuration, such as disabled certificate verification. - Outdated algorithms or protocols
For example, using MD5 or SHA1 for security, or old SSL/TLS versions. - Transitive vulnerabilities
A direct dependency depends on another vulnerable package. You do not see that package in yourrequirements.txt, but it is still in your environment. - Malicious packages
Sometimes an attacker uploads a package that looks similar to a popular one and contains malware.
Why Dependency Vulnerabilities Matter in Backends
Backends often:
- Process untrusted data from the internet
- Access sensitive data (databases, secrets, user data)
- Run on servers that are always online
That combination makes dependency vulnerabilities particularly dangerous.
Common Risk Scenarios
- Deserialization vulnerabilities
A library that deserializes user input (for example pickles, XML, YAML) might allow attackers to execute code. - Authentication and cryptography bugs
If a dependency that handles tokens, passwords, or encryption is flawed, attacker may bypass authentication or decrypt data. - Template injection
An unsafe templating engine can allow user input to be executed as code if not properly sandboxed. - File handling issues
Libraries that handle ZIP, TAR, image files, or PDFs may allow directory traversal or arbitrary file writes. - Command injection through wrappers
A library that wraps shell commands incorrectly might let user input escape and run arbitrary commands on your server.
How Vulnerabilities Get Discovered and Disclosed
Most dependency vulnerabilities are discovered by:
- Security researchers
- The library maintainers
- Bug bounty programs
- Automated scanners
Then they are usually:
- Assigned a CVE ID (Common Vulnerabilities and Exposures)
- Published in security advisories and databases
- Fixed in a new version of the package
Some key databases and sources:
| Source | Description |
|---|---|
| CVE database | Standardized IDs for vulnerabilities |
| NVD (NIST) | National Vulnerability Database with CVE details |
| GitHub Security Advisories | Package specific advisories |
| PyPI advisories | Security information for Python packages |
| Vendor blogs | Posts from framework or library maintainers |
Upgrading to the fixed version is usually the main mitigation.
Direct vs Transitive Dependencies
Understanding direct and transitive dependencies is important for assessing risk.
| Type | Description | Example |
|---|---|---|
| Direct dependency | You explicitly list it in your project | fastapi in requirements.txt |
| Transitive dependency | Installed because a direct dependency needs it | starlette installed via fastapi |
Example: dependency tree for fastapi (simplified):
fastapi==0.115.0
├─ starlette==0.37.0
└─ pydantic==2.9.0
└─ annotated-types==0.7.0
If there is a vulnerability in starlette or annotated-types, your application is still affected, even though you never added them manually.
You are responsible for vulnerabilities in all dependencies, including transitive ones.
Example: A Realistic Vulnerability Scenario
Imagine you use a JSON Web Token (JWT) library to verify access tokens:
from jose import jwt
def verify_token(token: str, secret: str) -> dict:
payload = jwt.decode(token, secret, algorithms=["HS256"])
return payloadNow suppose a vulnerability is discovered in this library:
- Under some conditions, tokens using
nonealgorithm are accepted without verification. - This is published as a CVE and fixed in version
3.4.0. - You still use version
3.2.0because you have not updated in a year.
An attacker can craft a token that bypasses signature validation and gets admin access.
Mitigation steps:
- Check if your version is affected.
- Read the advisory to understand impact and exploitation conditions.
- Upgrade to a safe version (for example
3.4.0or later). - Redeploy your backend.
- Consider revoking or rotating any long-lived tokens.
Tools for Detecting Dependency Vulnerabilities
You do not want to manually track security news for every package. Instead, use automated tools.
Ecosystem Specific Tools
For Python, typical tools are:
| Tool | Purpose |
|---|---|
pip-audit | Scan your installed packages or requirements for known vulnerabilities using Python advisory DB |
safety | Check requirements against a vulnerability database |
pip-tools | Helps manage pinned dependencies, not a scanner but essential for control |
Example usage of pip-audit:
pip install pip-audit
pip-auditSample output:
Found 1 known vulnerability in 1 package
Name Version ID Fix Versions
------- ------- --------- ------------
requests 2.19.1 PYSEC-2018-99 >=2.20.0
You then update requests to at least 2.20.0.
GitHub and GitLab Dependabot and Security Scans
If your code is hosted on GitHub or GitLab, you can enable:
- Automatic detection of vulnerable dependencies
- Security alerts and automated pull requests that bump versions
- Dependency graph visualization
Typical workflow:
- Dependabot opens a pull request:
- "Update
urllib3from 1.26.3 to 1.26.19" - Links to CVEs and advisories
- You review change, run tests, and merge if safe.
Good Practices for Managing Dependencies
Dependency management is one of the most important parts of backend security. Adopt these practices from the start.
1. Pin Versions
Always pin exact versions in your production dependencies instead of using unbounded ranges.
Bad:
fastapi
sqlalchemy>=2.0Better:
fastapi==0.115.0
sqlalchemy==2.0.34This ensures:
- Reproducible environments
- You know exactly what versions are running in production
- Upgrades are explicit and reviewable
Use a separate file for development and testing dependencies, like:
requirements.txtfor applicationrequirements-dev.txtfor tools such aspytest,black,mypy
2. Separate Direct Dependencies from Lock Files
A common pattern:
- Maintain a short
requirements.inorpyproject.tomlwith direct dependencies. - Generate a full, pinned
requirements.txtor lock file that includes all transitive dependencies.
Tools like pip-tools or poetry can help with this.
Example with pip-tools:
requirements.in:
fastapi
uvicorn[standard]
sqlalchemy
psycopg2-binaryGenerate the full list:
pip-compile requirements.in
This produces a requirements.txt with all versions pinned, including transitive ones.
Always deploy with a fully pinned dependency list or lock file. Never deploy with floating versions in production.
3. Regular Dependency Updates
Do not wait years between updates. Instead:
- Schedule regular updates, for example every 1 to 4 weeks.
- Run security scans at least weekly, ideally on each commit.
- Prefer small, frequent updates rather than huge one-time upgrades.
A simple practice:
- Once a week, run:
pip-audit- If vulnerabilities are found, upgrade the affected packages.
- Run tests and deploy.
4. Apply Security Patches Quickly
Treat security fixes differently from ordinary feature updates:
- If a security advisory affects a package you use, prioritize updating.
- Even if it is a minor version bump, run tests and deploy as soon as possible.
- For critical vulnerabilities, deploy a hotfix.
Many teams classify updates:
| Type | Response time target |
|---|---|
| Critical security | Same day or next business day |
| High severity | Within a few days |
| Medium / low | In regular scheduled update window |
5. Avoid Unmaintained Packages
Before adding a new dependency, check:
- Last release date
- Number of open issues and pull requests
- Activity in the issue tracker
- Whether security issues are addressed promptly
If a package has not been updated in many years, and there are open security issues, consider alternatives.
6. Minimize Dependencies
Each dependency is potential attack surface. Ask:
- Do I really need this package?
- Can I implement this with the standard library?
- Am I using only 5 percent of a huge library?
For example:
- Instead of adding a whole utility library just to parse URLs, use the standard
urllib.parse. - Instead of a massive "kitchen sink" framework, use focused libraries when possible.
Less code from others often means fewer vulnerabilities for you.
Handling Vulnerabilities When They Are Found
At some point, you will discover that your project uses a vulnerable dependency. Have a simple playbook.
Step 1: Confirm and Assess
- Check if your project actually uses the vulnerable code path.
- Read the advisory details:
- What versions are affected
- What configurations are required for exploitation
- Impact: data leak, code execution, privilege escalation, etc.
Even if you think it is unlikely, treat it as serious. Attackers might find exotic ways to reach vulnerable code.
Step 2: Update to a Fixed Version
- Update to the minimum safe version mentioned in the advisory.
- Prefer a minimal bump, for example from
1.2.3to1.2.5, instead of jumping across many major versions during a quick patch. - Update your pinned dependency file and lock file.
Example:
pip install "requests>=2.31.0" --upgrade
pip freeze > requirements.txtOr with a tool:
pip-compile --upgrade-package requests requirements.inStep 3: Test and Deploy
- Run your unit and integration tests.
- If the change is small and tests pass, deploy a hotfix.
- If the update is large, consider more thorough regression testing.
Step 4: Post-Update Checks
Depending on the severity:
- Consider invalidating sessions or tokens if the vulnerability relates to authentication.
- Rotate secrets (API keys, database passwords) if the vulnerability might expose them.
- Review logs for suspicious activity near the time of possible exploitation.
Preventing Malicious Package Attacks
Some attacks are not bugs but intentionally malicious packages. Common patterns include:
- Typo-squatting:
reqeustsinstead ofrequests - Brand-jacking: a package with the same name as another ecosystem
- Compromised maintainers: attackers publish a malicious update in a legitimate project
Defenses:
- Double check package names
Verify you are installing the correct package, especially if you typed it by hand. - Check the source repository
Confirm the package points to a legitimate GitHub or similar repository. - Avoid copy pasting random
pip installcommands from unknown sources
Prefer official documentation. - Pin versions and review updates
If a popular package suddenly adds suspicious code, a code review of changes can catch it.
Dependency Vulnerabilities in CI/CD Pipelines
Your CI/CD system is a good place to integrate dependency security checks.
Typical pipeline steps:
- Install dependencies from the lock file.
- Run unit tests.
- Run security scans:
pip-auditorsafety- Optional: secret scanning, static analysis
- Fail the pipeline if:
- There are high or critical known vulnerabilities.
- Require a human to review and approve version changes.
This leads to a consistent rule:
Never deploy a backend that your CI pipeline reports as containing high or critical dependency vulnerabilities.
If you must deploy a temporary exception, document it and track it in your issue system.
Dependency Vulnerabilities and Containers
If you use Docker (covered later in the course), you also need to think about vulnerabilities in:
- The base image (for example the OS packages)
- Python packages inside the image
- System level libraries (OpenSSL, libxml2, etc.)
Common practices:
- Use official, minimal base images, for example
python:3.12-slim. - Regularly rebuild images with updated base images, not just update Python packages.
- Run container image scanners that check OS level vulnerabilities (for example Trivy, Grype).
Your dependency stack becomes:
| Layer | Examples |
|---|---|
| Application code | Your Python files |
| Python dependencies | FastAPI, SQLAlchemy, requests |
| System libraries | OpenSSL, libc, zlib |
| OS packages | Debian/Ubuntu/Alpine base image |
Vulnerabilities can exist at any layer.
Summary
Dependency vulnerabilities are one of the main ways a backend becomes insecure. You must:
- Understand that all direct and transitive dependencies can be vulnerable.
- Pin versions and use lock files for reproducible environments.
- Use automated tools and CI to detect vulnerabilities early.
- Update and patch promptly when advisories are published.
- Minimize and choose dependencies carefully.
- Integrate security scanning into deployment pipelines and container builds.
Managing dependencies well is a core responsibility of a backend developer, not just a task for security specialists.
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!