5.4. pip and Package Management
Table of Contents
Why Package Management Matters
Modern backend development depends on thousands of reusable libraries. Instead of writing everything from scratch, you install and reuse these libraries in your projects.
Python uses a tool called pip to:
- Download packages from the internet
- Install them into your environment
- Uninstall or upgrade them when needed
A package manager solves three main problems:
- Discovering packages by name.
- Installing correct versions with all their dependencies.
- Reproducing the same setup on another machine.
Without proper package management, your code might:
- Work on your computer, but not on the server.
- Break when a library releases a new incompatible version.
- Be impossible to set up again in the future.
In this chapter, you will learn how to use pip in a way that is safe and suitable for backend projects.
Installing and Upgrading Packages with pip
When you installed Python, you normally got pip along with it.
You can check that pip is available with:
pip --versionor, more explicit:
python -m pip --version
Using python -m pip is often safer, because it guarantees you use the pip that belongs to that specific Python interpreter.
Basic installation
To install a package:
pip install requestsThis will:
- Download the latest version of
requestsfrom the Python Package Index (PyPI). - Install
requestsand any libraries it depends on.
You can then use it in your code:
import requests
response = requests.get("https://example.com")
print(response.status_code)Installing a specific version
You often want fixed versions in backend projects, so your environment is predictable.
pip install "requests==2.31.0"Other version operators:
| Operator | Meaning | Example |
|---|---|---|
== | Exactly this version | requests==2.31.0 |
>= | This version or newer | requests>=2.28.0 |
<= | This version or older | requests<=2.31.0 |
> | Strictly higher version | requests>2.0.0 |
< | Strictly lower version | requests<3.0.0 |
~= | Compatible release, same major.minor series | requests~=2.31 |
Example:
pip install "fastapi~=0.111"This means “install FastAPI 0.111.x, but not 0.112 or higher”.
In backend projects, always pin versions in your dependency files, for example package==1.2.3. This makes deployments and production behavior predictable.
Upgrading and reinstalling
Upgrade a package to the latest version:
pip install --upgrade requests
# or shorter:
pip install -U requestsUpgrade to a specific version:
pip install "requests==2.32.0"Force reinstall (useful if an installation got corrupted):
pip install --force-reinstall "requests==2.31.0"Uninstalling packages
To remove a package:
pip uninstall requests
You will be asked to confirm. Answer y or yes to proceed.
Listing and Inspecting Installed Packages
Understanding what is installed in your environment is important, especially on servers or in virtual environments.
Listing installed packages
To list all installed packages:
pip listExample output (shortened):
Package Version
---------- -------
pip 24.0
setuptools 69.0.0
requests 2.31.0
fastapi 0.111.0
uvicorn 0.30.0To include packages that pip did not install (like some system packages):
pip list --localShowing details about a package
To see detailed information about a specific package:
pip show requestsExample output:
Name: requests
Version: 2.31.0
Summary: Python HTTP for Humans.
Home-page: https://requests.readthedocs.io
Author: Kenneth Reitz
License: Apache 2.0
Location: /path/to/venv/lib/python3.11/site-packages
Requires: certifi, charset-normalizer, idna, urllib3
Required-by: some-other-packageThis helps you:
- See the installed version.
- See where it is installed.
- Understand dependencies (
Requires). - See what depends on it (
Required-by).
Checking outdated packages
To see which installed packages have newer versions available:
pip list --outdatedExample:
Package Version Latest Type
-------- ------- ------ -----
uvicorn 0.30.0 0.31.0 wheel
fastapi 0.111.0 0.112.0 wheelIn production projects, you normally do not upgrade everything blindly. You upgrade carefully and test.
Requirements Files and Dependency Freezing
For real backend projects, you must be able to recreate the exact same environment on:
- your local machine
- teammates' machines
- CI servers
- production servers
You do this using a requirements file.
What is a requirements file?
A requirements.txt file is a plain text file that lists all your project dependencies.
Simple example:
fastapi==0.111.0
uvicorn[standard]==0.30.0
sqlalchemy==2.0.30
psycopg2-binary==2.9.9
python-dotenv==1.0.1Installing from a requirements file
To install everything from this file:
pip install -r requirements.txtThis is how you:
- Set up a new environment for a project
- Set up CI/CD
- Set up production servers
Creating a requirements file manually
For small projects, you can just write requirements.txt by hand.
Example scenario:
You create a new FastAPI project and install some packages:
pip install fastapi uvicorn[standard]
pip install sqlalchemy psycopg2-binary
Then you create requirements.txt:
fastapi==0.111.0
uvicorn[standard]==0.30.0
sqlalchemy==2.0.30
psycopg2-binary==2.9.9You get the exact installed versions with:
pip show fastapi uvicorn sqlalchemy psycopg2-binary
or by using pip freeze as explained next.
Freezing dependencies with pip freeze
pip freeze prints all installed packages in a format that pip install -r understands:
pip freezeExample output (shortened):
anyio==4.4.0
fastapi==0.111.0
idna==3.7
pydantic==2.8.0
sniffio==1.3.1
starlette==0.37.2
typing_extensions==4.12.2
uvicorn==0.30.0You can redirect this into a file:
pip freeze > requirements.txt
Now requirements.txt contains the full dependency tree, not just your top level packages, for example:
fastapi==0.111.0
pydantic==2.8.0
starlette==0.37.2
typing_extensions==4.12.2
uvicorn==0.30.0
...
pip freeze includes everything in your current environment. Only run it inside a clean virtual environment that belongs to a single project. Never run it in a global interpreter.
Top level vs full freeze
There are two common strategies:
| Strategy | Description | Pros | Cons |
|---|---|---|---|
| Top level only | You list only the libraries you directly use | Short and readable file | Less precise, installs latest sub-deps |
| Full freeze (pip freeze) | You list every installed dependency | Fully reproducible environments | Long file, includes indirect dependencies |
For backend projects you want reproducibility, so full freeze is common, especially for production.
A typical approach:
- Maintain
requirements.inwith only top level dependencies:
fastapi
uvicorn[standard]
sqlalchemy
psycopg2-binary- Generate
requirements.txtusing a tool (such aspip-tools) that pins all versions.
You will learn about more advanced tools later. For now it is enough to understand the idea.
Optional Dependencies and Extras
Some packages provide optional features that you can enable with extras. You saw a glimpse of this with uvicorn[standard].
What are extras?
An extra is a named group of additional dependencies that add some feature, usually written in square brackets.
Example:
pip install "uvicorn[standard]"
uvicorn defines an extra called standard. It might include things like:
uvloopfor faster event loophttptoolsfor faster HTTP parsing
You get a more fully featured Uvicorn server with one command.
You can also combine extras:
pip install "somepackage[redis,postgres]"This installs:
somepackagebase- Additional dependencies for the
redisextra - Additional dependencies for the
postgresextra
You do not need to know how to define extras yet, just how to use them when a package documents them.
Optional dependencies in practice
Examples you will likely see in backend work:
pip install "sqlalchemy[asyncio]"
pip install "fastapi[all]"
pip install "httpx[http2]"You should always follow the project documentation. It will mention which extras you should enable for your use case.
Managing Dependencies Across Environments
Backend applications typically have multiple environments:
- Development on your machine
- Testing or CI
- Production
You usually want:
- Core dependencies everywhere
- Extra tools only in development or testing
Splitting dependencies: prod vs dev
You can use multiple requirements files.
Example:
requirements.txt (for production):
fastapi==0.111.0
uvicorn[standard]==0.30.0
sqlalchemy==2.0.30
psycopg2-binary==2.9.9
python-dotenv==1.0.1
requirements-dev.txt (for development):
-r requirements.txt
pytest==8.2.0
pytest-asyncio==0.23.0
pytest-cov==5.0.0
black==24.4.2
isort==5.13.2
The -r requirements.txt line tells pip: “first install everything from requirements.txt”.
To install only production dependencies:
pip install -r requirements.txtTo install both production and dev dependencies:
pip install -r requirements-dev.txtExample: different environments
Imagine your FastAPI project:
- Production server should not have development tools like linters and test frameworks.
- Developers need tests and code formatters.
So your workflow:
- On your development machine:
pip install -r requirements-dev.txt- On the production server:
pip install -r requirements.txtThis keeps production environments smaller and reduces attack surface.
Common pip Commands for Backend Projects
Here is a summary of pip commands you will use again and again.
Installation commands
| Task | Command example |
|---|---|
| Install latest version | pip install fastapi |
| Install specific version | pip install "fastapi==0.111.0" |
| Install with extras | pip install "uvicorn[standard]" |
| Install from requirements | pip install -r requirements.txt |
| Install from local directory | pip install . (in a directory with pyproject.toml) |
Inspection commands
| Task | Command example |
|---|---|
| Check pip version | pip --version |
| List installed packages | pip list |
| List outdated packages | pip list --outdated |
| Show details for a package | pip show fastapi |
| Generate a full freeze file | pip freeze > requirements.txt |
Maintenance commands
| Task | Command example |
|---|---|
| Upgrade a package | pip install --upgrade fastapi |
| Upgrade to specific ver | pip install "fastapi==0.112.0" |
| Uninstall a package | pip uninstall fastapi |
| Reinstall a package | pip install --force-reinstall package |
Typical Workflow in a Backend Project
To put all of this together, here is a simple but realistic example workflow.
Starting a new backend project
- Create and activate a virtual environment (covered in the “Virtual Environments” chapter).
- Install initial dependencies:
pip install fastapi uvicorn[standard]- Start coding:
# main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello Backend"}- Run the app:
uvicorn main:app --reload- Freeze dependencies:
pip freeze > requirements.txtNow you have a reproducible environment.
Adding a new library later
You decide to store data in PostgreSQL using SQLAlchemy:
- Install new dependencies:
pip install sqlalchemy psycopg2-binary- Update
requirements.txt:
pip freeze > requirements.txt- Commit code and
requirements.txtto version control.
Setting up on another machine
On another computer or a server:
- Create and activate a virtual environment.
- Install dependencies:
pip install -r requirements.txtNow this environment has exactly the same package versions, so your backend behaves the same.
Good Practices and Common Pitfalls
You now know the mechanics of pip. To use it safely in backend work, keep these rules in mind.
Good practices
- Use virtual environments for every project.
- Pin versions in production using
==. - Store requirements files in your repository.
- Split dev and prod requirements if needed.
- Use
python -m pipto avoid mixing Python versions. - Document how to install dependencies in your project README.
Example README section:
## Setup
1. Create virtual environment:
python -m venv .venv
2. Activate it:
# Windows:
.venv\Scripts\activate
# macOS / Linux:
source .venv/bin/activate
3. Install dependencies:
pip install -r requirements.txtCommon pitfalls
| Pitfall | Why it is a problem | Better approach |
|---|---|---|
| Using global Python for all projects | Package conflicts between projects | Use one virtual environment per project |
| Not pinning versions in production | Apps break when packages release incompatible updates | Use == versions in requirements.txt |
Running pip freeze in a polluted environment | Requirements include unrelated packages | Use clean virtual environments per project |
| Installing dev tools in production | Larger attack surface and slower deployments | Separate requirements.txt and requirements-dev.txt |
Using pip without specifying Python version | Risk of mixing up Python 3 vs system default | Use python -m pip |
By following these patterns you will be able to manage your backend project dependencies in a professional, reliable way.
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!