5.3. Virtual Environments
Table of Contents
Why Virtual Environments Matter
When you build Python backend applications, you almost never work with "plain Python" only. You install many external packages: FastAPI, SQLAlchemy, pytest, etc.
If you install everything globally on your system, you quickly get into trouble:
- Different projects need different versions of the same package.
- Updating a package for one project can break another.
- Your system Python becomes messy and hard to debug.
- Reproducing your setup on another machine is difficult.
A virtual environment is an isolated Python environment for one project.
Each project gets its own Python, its own pip, and its own installed packages.
A virtual environment is an isolated directory that contains:
- Its own Python interpreter
- Its own
pipcommand - Its own copy of installed packages
It does not change, replace, or "break" your system Python.
Using virtual environments is considered a must for modern Python development, especially for backend work.
Key Concepts
Global Python vs Virtual Environment
You usually have one or more global Python installations:
- On Linux or macOS: often preinstalled.
- On Windows: installed from python.org or Microsoft Store.
Global Python lives in system locations, for example:
- Linux:
/usr/bin/python3 - macOS:
/usr/local/bin/python3or viapyenv,brew, etc. - Windows:
C:\Python311\python.exeor similar
A virtual environment is simply a directory inside your project, for example:
myproject/venv/myproject/.venv/
This directory contains:
- A copy or link to Python.
- A
bin/orScripts/folder withpythonandpip. - A
site-packages/folder where all project dependencies are installed.
Why Isolation Is Important
Isolation solves several common problems:
| Problem | Without venv | With venv |
|---|---|---|
| Different project dependencies | Conflicting versions | Each project has its own versions |
| Upgrading a package | Might break other projects | Affects only that project |
| Reproducing environment elsewhere | Hard to remember everything | Use requirements.txt with that venv |
| Cleaning up unused packages | Risky to remove globally | Just remove the project or its venv |
Creating Virtual Environments
Python includes a built-in module for this: venv.
There are other tools, but venv is standard and enough for now.
Basic Creation Command
From your terminal or command prompt, go to your project directory:
cd /path/to/your/projectThen run:
python -m venv venvThis:
- Uses your current
pythoninterpreter. - Creates a folder called
venvinside your project.
You can use another name instead of venv, for example .venv:
python -m venv .venv
Both are common. .venv is popular because the leading dot often hides it from file explorers, and many tools detect it automatically.
What Gets Created
On Linux / macOS (with python -m venv venv):
myproject/
venv/
bin/
python
pip
activate
lib/
python3.x/
site-packages/
pyvenv.cfg
your_code.pyOn Windows:
myproject/
venv/
Scripts/
python.exe
pip.exe
activate.bat
Lib/
site-packages/
pyvenv.cfg
your_code.py
You never need to touch most of these files manually.
You mostly care about:
venv/bin/pythonorvenv\Scripts\python.exevenv/bin/piporvenv\Scripts\pip.exe- The activation script (
activate,activate.bat, etc.)
Activating and Deactivating
You can work with a virtual environment with or without activation, but activation makes things much more convenient.
Activating on Linux / macOS
From your project directory:
source venv/bin/activate
or if you used .venv:
source .venv/bin/activateAfter activation, your prompt usually changes, for example:
(venv) user@machine:~/myproject$Now when you type:
pythonor:
pipyou are using the versions inside the virtual environment, not the global ones.
Activating on Windows (Command Prompt)
From your project directory:
venv\Scripts\activate
or if you used .venv:
.venv\Scripts\activateYou should see:
(venv) C:\path\to\myproject>
Now python and pip will point to the virtual environment.
Activating on Windows (PowerShell)
From your project directory:
.\venv\Scripts\Activate.ps1or:
.\.venv\Scripts\Activate.ps1If you get an execution policy error, you may need to allow running local scripts, for example:
Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSignedThen try activating again.
Deactivating
To leave the virtual environment on any platform:
deactivate
Your prompt will return to normal, and python / pip will again be the global ones.
Rule
Always check your prompt for (venv) or (.venv) before:
- Installing packages with
pip install - Running your Python application
- Running tests
If you forget to activate, you may install packages globally by mistake.
Using `pip` Inside a Virtual Environment
Once the virtual environment is activated, the pip command uses the venv by default.
Example on any platform:
(venv) pip install fastapi uvicorn
This will install fastapi and uvicorn only inside venv.
You can check where pip is installing packages:
(venv) which pip # Linux / macOS
(venv) where pip # WindowsYou can also check installed packages:
(venv) pip listInstalling Specific Versions
To control versions clearly:
(venv) pip install fastapi==0.111.0
(venv) pip install "uvicorn[standard]==0.27.0.post1"This version pinning is critical when building backend APIs that must behave the same in development and production.
Checking Which Python You Are Using
It is useful to verify that you are using the venv Python:
On Linux / macOS:
(venv) which pythonOutput will be something like:
/home/user/myproject/venv/bin/pythonOn Windows:
(venv) where pythonOutput will be something like:
C:\path\to\myproject\venv\Scripts\python.exe
If it points to a system path like /usr/bin/python3 or C:\Python311\python.exe while you expect the venv, you are either not activated or something is misconfigured.
Virtual Environments and Project Structure
A common and practical structure for backend projects is:
myproject/
.venv/ # or venv/
app/
__init__.py
main.py
...
tests/
requirements.txt
README.mdWhy keep `venv` inside the project?
Pros:
- Easy to see the environment tied to the project.
- Simple to delete: remove the folder to start fresh.
- Many editors automatically detect
.venvinside the project.
Cons:
- The folder can be large, so you must ignore it in Git.
Ignore Virtual Environment in Git
Create a .gitignore file in your project and add:
venv/
.venv/
So Git does not track the virtual environment.
You never commit the venv to your repository.
Recreating Environments with `requirements.txt`
To share dependencies between machines, you do not share the venv itself.
You share a list of packages instead.
Common pattern:
- Install packages inside your venv:
(venv) pip install fastapi uvicorn
(venv) pip install sqlalchemy psycopg2-binary- Freeze current dependencies to a file:
(venv) pip freeze > requirements.txt
Now requirements.txt might contain:
fastapi==0.111.0
uvicorn==0.27.0.post1
SQLAlchemy==2.0.30
psycopg2-binary==2.9.9- On another machine (or after deleting the venv), you can recreate it:
python -m venv venv
source venv/bin/activate # or venv\Scripts\activate on Windows
pip install -r requirements.txt pip install -r requirements.txt
Rule
To reproduce a Python environment:
- Create a new virtual environment.
- Activate it.
- Install packages using:
Common Mistakes and How to Avoid Them
1. Installing Packages Globally by Accident
Symptom:
pip install fastapiseems to work.- Inside your code,
import fastapifails or works differently. pip listinside venv does not show the package.
Cause: You installed the package without activating the venv.
How to fix:
- Activate the virtual environment.
- Run
pip installagain.
2. Running the Wrong Python
Symptom:
python app/main.pyuses different packages than expected.which pythonorwhere pythonpoints to system Python.
Cause: Virtual environment not activated, or you are in another shell.
Fix:
- Activate the virtual environment in that terminal.
- Always run
pythonfrom an activated venv, or call it explicitly:
venv/bin/python app/main.py # Linux / macOS
venv\Scripts\python.exe app\main.py # Windows3. Committing the venv Folder to Git
Symptom:
- Your repository is huge.
- Many platform-specific files are in Git.
Cause: venv/ or .venv/ not in .gitignore.
Fix:
- Add
venv/and.venv/to.gitignore. - Remove them from Git history if already committed.
Examples: Step by Step on Each Platform
Example on Linux / macOS
# 1. Create project folder
mkdir backend-example
cd backend-example
# 2. Create virtual environment
python -m venv .venv
# 3. Activate it
source .venv/bin/activate
# 4. Check Python and pip
which python
which pip
# 5. Install dependencies
pip install fastapi uvicorn
# 6. Save dependencies
pip freeze > requirements.txt
# 7. Run Python using this environment
python -c "import fastapi; print(fastapi.__version__)"
# 8. When done
deactivateExample on Windows (Command Prompt)
REM 1. Create project folder
mkdir backend-example
cd backend-example
REM 2. Create virtual environment
python -m venv venv
REM 3. Activate it
venv\Scripts\activate
REM 4. Check Python and pip
where python
where pip
REM 5. Install dependencies
pip install fastapi uvicorn
REM 6. Save dependencies
pip freeze > requirements.txt
REM 7. Run Python using this environment
python -c "import fastapi; print(fastapi.__version__)"
REM 8. When done
deactivateVirtual Environments in Editors and IDEs
Modern editors and IDEs can detect and use your virtual environment automatically.
VS Code
Typical steps:
- Create a venv, for example
.venv. - Open the project folder in VS Code.
- In the bottom status bar, click on the Python version.
- Choose the interpreter inside
.venv, for example: .venv/bin/pythonon Linux / macOS.venv\Scripts\python.exeon Windows
VS Code will then:
- Use the venv for running and debugging.
- Use venv packages for IntelliSense and autocompletion.
PyCharm
When creating or importing a project, PyCharm can:
- Detect an existing virtual environment.
- Or create a new one in
.venvor another folder.
You usually set this in "Project Interpreter" settings.
When to Create a New Virtual Environment
A good rule:
Create a new virtual environment for every new Python project.
You typically create a venv when:
- You start a new backend application or service.
- You clone someone else's project repository.
- You want to try a new library in isolation.
You usually do not create a new venv:
- For every small script that is part of the same project.
- For standard library experiments that do not use external packages.
Summary
In this chapter you learned:
- What a virtual environment is and why it is essential for backend work.
- How to create one using
python -m venv venvorpython -m venv .venv. - How to activate and deactivate it on Linux, macOS, and Windows.
- How to use
pipinside the virtual environment to install project-specific dependencies. - How to reproduce environments with
requirements.txt. - How to avoid common mistakes like installing packages globally by accident or committing
venv/to Git.
You will use virtual environments in almost every Python backend chapter that follows, including FastAPI, databases, testing, and deployment, so practice these steps until they feel natural.
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!