5.5. Python Project Structure
Table of Contents
Why Project Structure Matters
When you build small scripts, you can put everything in a single file. For real backend services, that quickly becomes painful.
A clear project structure helps you:
- Find code quickly.
- Reuse code instead of copying it.
- Test and debug more easily.
- Work in a team without stepping on each other’s toes.
In this chapter you will see:
- How a simple Python project is laid out.
- How that grows into a typical backend project structure.
- Where to put configuration, tests, and dependencies.
- How to run your code as a package, not just as a loose script.
We will keep examples framework neutral, but everything here works very well with FastAPI and other backend frameworks.
Minimal Python Project Layout
Start with the smallest layout that is still “real”:
my_project/
my_project/
__init__.py
main.py
tests/
test_example.py
README.md
pyproject.toml # or requirements.txt + setup.cfg, etc.This is called a “src layout” or “package layout”. The important parts:
- Outer
my_project/
The root folder. Git repository usually lives here. - Inner
my_project/
A Python package. The name is the same as the project. It contains your actual code. __init__.py
Tells Python that this directory is a package. Can be empty.main.py
Entry point or starting module.tests/
All tests go here.pyproject.tomlorrequirements.txt
List of dependencies and project metadata.
This is better than putting code directly in the root folder, because it avoids import problems and makes packaging easier.
Example: A Tiny App
my_project/main.py:
def greet(name: str) -> str:
return f"Hello, {name}!"
def main() -> None:
message = greet("Backend Developer")
print(message)
if __name__ == "__main__":
main()
tests/test_example.py:
from my_project.main import greet
def test_greet():
assert greet("World") == "Hello, World!"You can run tests with:
pytestThis simple structure already gives you:
- A dedicated place for code.
- A dedicated place for tests.
- Importable modules like
from my_project.main import greet.
Package vs Script: Why You Want a Package
A single script file can be useful:
python my_script.pyBut for backends you need multiple modules, and you need imports to work reliably.
Script Layout
project/
app.py
app.py:
from utils import helper_function # This will often fail
Now if you move utils.py around or run the script from a different directory, imports break.
Package Layout
project/
my_app/
__init__.py
app.py
utils.py
app.py:
from my_app.utils import helper_functionYou can now run things using the module syntax:
python -m my_app.appHere Python knows where the package is and resolves imports correctly.
python -m package_name.module_name
Important rule
Always structure non-trivial backends as a package, not as a single loose script. Put code inside a named directory with an __init__.py file, and run it with:
This avoids many hard-to-debug import issues as your project grows.
Typical Backend Project Structure
Let us grow the minimal layout into something closer to a real backend:
my_backend/
my_backend/
__init__.py
main.py # Application entry point
config.py # App configuration helpers
db.py # Database connection setup
api/
__init__.py
routes.py # Group of API routes
schemas.py # Pydantic or data models for requests/responses
core/
__init__.py
settings.py # Central settings
security.py # Security related helpers
services/
__init__.py
user_service.py
email_service.py
models/
__init__.py
user.py # Database models
order.py
tests/
__init__.py
test_routes.py
test_services.py
requirements.txt or pyproject.toml
README.mdHigh Level Purpose of Folders
| Folder | Purpose |
|---|---|
my_backend/ (inner) | All application code as a package. |
api/ | Web layer, request handlers, route definitions. |
core/ | Core infrastructure, settings, security utilities. |
services/ | Business logic, independent of HTTP and database details. |
models/ | Database models or domain entities. |
tests/ | Automated tests for all components. |
You do not have to use these exact names, but separating “layers” is very helpful.
Grouping Code by Responsibility
There are two common styles:
- Layered by technical responsibility
Example folders:api,services,repositories,models. - Grouped by feature or module
Example folders:users,orders,payments, each containing routes, services, models.
For a beginner, layered structure is easier to start with. Later you can move to feature modules if needed.
Example: Layered Structure
my_backend/
my_backend/
api/
users.py
auth.py
services/
user_service.py
auth_service.py
models/
user.py
db.py
main.pyHere:
api/*knows HTTP (e.g. FastAPI routes).services/*knows business rules, but not HTTP.models/*defines how data is stored or represented.db.pycreates a shared database connection or session.main.pywires it all together.
Example Files
models/user.py:
from dataclasses import dataclass
@dataclass
class User:
id: int
email: str
is_active: bool
services/user_service.py:
from my_backend.models.user import User
class UserService:
def __init__(self, user_repository):
self.user_repository = user_repository
def get_user_by_id(self, user_id: int) -> User | None:
return self.user_repository.find_by_id(user_id)
def deactivate_user(self, user_id: int) -> None:
user = self.user_repository.find_by_id(user_id)
if not user:
return
user.is_active = False
self.user_repository.save(user)
api/users.py (using a fake “framework-like” interface):
from my_backend.services.user_service import UserService
from my_backend.repositories.user_repository import UserRepository
user_service = UserService(user_repository=UserRepository())
def get_user_handler(request):
user_id = int(request.path_params["user_id"])
user = user_service.get_user_by_id(user_id)
if not user:
return {"status": 404, "body": {"detail": "User not found"}}
return {"status": 200, "body": {"id": user.id, "email": user.email}}Even without a specific framework, you can see:
- HTTP-specific logic is in
api/users.py. - Business logic is in
services. - Data structures are in
models.
This separation will matter a lot once your app grows.
Where to Put Configuration
Backends need configuration:
- Database URLs.
- Secret keys.
- Debug flags.
- Third-party API keys.
You should:
- Keep defaults in code.
- Override with environment variables per environment.
A simple pattern is to have a config.py or core/settings.py file.
Example: Settings Module
my_backend/core/settings.py:
import os
from dataclasses import dataclass
@dataclass
class Settings:
debug: bool = False
database_url: str = "sqlite:///./dev.db"
secret_key: str = "CHANGE_ME"
@classmethod
def from_env(cls) -> "Settings":
return cls(
debug=os.getenv("APP_DEBUG", "false").lower() == "true",
database_url=os.getenv("DATABASE_URL", "sqlite:///./dev.db"),
secret_key=os.getenv("SECRET_KEY", "CHANGE_ME"),
)
settings = Settings.from_env()Use it anywhere:
from my_backend.core.settings import settings
def connect_db():
print(f"Connecting to {settings.database_url}")Organizational rules:
- Put configuration logic in one place.
- Import settings where needed, instead of reading environment variables all over your code.
- Do not hardcode secrets in code in real projects.
Entry Points: `main.py` and `__main__`
Your project needs a clear “start here” file.
Common patterns:
Simple CLI style entry
my_backend/main.py:
def main() -> None:
print("Starting backend...")
if __name__ == "__main__":
main()Run:
python -m my_backend.mainFramework entry
For a web backend, you usually have an “app” object.
Example with a fake framework:
# my_backend/main.py
from my_backend.api.routes import app
def run():
# Imagine `app.run()` starts a server
app.run()
If your server process (for example, uvicorn) needs the app, you point it to my_backend.main:app.
uvicorn my_backend.main:app --reloadKey idea:
Important rule
Have a single, small entry point file, such as main.py, where you create the app, load configuration, and start the server. Do not scatter “startup” code all over the project.
Tests and Their Structure
Always keep tests in a separate tests/ folder at the project root:
my_backend/
my_backend/
...
tests/
__init__.py
test_users.py
test_auth.py
test_services/
test_user_service.pyYou can mirror the application structure:
tests/test_users.pytestsapi/users.py.tests/test_services/test_user_service.pytestsservices/user_service.py.
Simple Service Test Example
tests/test_user_service.py:
from my_backend.services.user_service import UserService
from my_backend.models.user import User
class FakeUserRepository:
def __init__(self):
self.users = {
1: User(id=1, email="user@example.com", is_active=True)
}
def find_by_id(self, user_id: int) -> User | None:
return self.users.get(user_id)
def save(self, user: User) -> None:
self.users[user.id] = user
def test_deactivate_user():
repo = FakeUserRepository()
service = UserService(user_repository=repo)
service.deactivate_user(1)
assert repo.users[1].is_active is FalseKeeping tests organized:
- Avoid mixing test files and application files in the same directories.
- Use clear file names like
test_<module>.py.
Handling Dependencies: `requirements.txt` and `pyproject.toml`
Your project should declare which packages it needs. Two common approaches:
1. Using `requirements.txt`
my_backend/
requirements.txtExample content:
fastapi==0.115.0
uvicorn[standard]==0.30.0
sqlalchemy==2.0.35
psycopg2-binary==2.9.9Install with:
pip install -r requirements.txt2. Using `pyproject.toml` (modern way)
pyproject.toml:
[project]
name = "my-backend"
version = "0.1.0"
description = "Example backend project"
requires-python = ">=3.11"
dependencies = [
"fastapi==0.115.0",
"uvicorn[standard]==0.30.0",
"sqlalchemy==2.0.35",
]
[tool.pytest.ini_options]
testpaths = ["tests"]
pythonpath = ["."]
Then you can use tools such as pip, pip-tools, or uv to install from pyproject.toml.
Organizational rules:
- Keep one central place where dependencies are listed.
- Use a virtual environment for each project.
- Pin versions for reproducible builds when your project becomes serious.
Example: Simple Backend Structure from Scratch
Let us outline a tiny but realistic project that could later become a FastAPI app.
todo_backend/
todo_backend/
__init__.py
main.py
core/
__init__.py
settings.py
api/
__init__.py
todos.py
models/
__init__.py
todo.py
services/
__init__.py
todo_service.py
tests/
test_todo_service.py
pyproject.toml
README.mdCore Domain Model
todo_backend/models/todo.py:
from dataclasses import dataclass
from datetime import datetime
@dataclass
class Todo:
id: int
title: str
completed: bool = False
created_at: datetime = datetime.utcnow()Business Logic Service
todo_backend/services/todo_service.py:
from typing import List, Dict
from todo_backend.models.todo import Todo
class InMemoryTodoRepository:
def __init__(self) -> None:
self._todos: Dict[int, Todo] = {}
self._next_id = 1
def list_todos(self) -> List[Todo]:
return list(self._todos.values())
def create_todo(self, title: str) -> Todo:
todo = Todo(id=self._next_id, title=title)
self._todos[self._next_id] = todo
self._next_id += 1
return todo
def mark_done(self, todo_id: int) -> None:
todo = self._todos.get(todo_id)
if todo:
todo.completed = True
class TodoService:
def __init__(self, repository: InMemoryTodoRepository) -> None:
self.repository = repository
def get_all(self) -> List[Todo]:
return self.repository.list_todos()
def add(self, title: str) -> Todo:
return self.repository.create_todo(title)
def complete(self, todo_id: int) -> None:
self.repository.mark_done(todo_id)API Layer (Pseudocode)
todo_backend/api/todos.py:
from todo_backend.services.todo_service import TodoService, InMemoryTodoRepository
repo = InMemoryTodoRepository()
service = TodoService(repository=repo)
def list_todos_handler(request):
todos = service.get_all()
return {
"status": 200,
"body": [{"id": t.id, "title": t.title, "completed": t.completed} for t in todos],
}
def create_todo_handler(request):
data = request.json()
new_todo = service.add(title=data["title"])
return {
"status": 201,
"body": {"id": new_todo.id, "title": new_todo.title, "completed": new_todo.completed},
}You could plug these handlers into any HTTP framework, but the structure of your project would stay almost the same.
Entry Point
todo_backend/main.py:
# Here you would create a real app with a framework.
# For illustration we just show where that would live.
def main() -> None:
print("Todo backend starting...")
if __name__ == "__main__":
main()You can see how each part has a clear place:
- Domain, models:
models/. - Business logic:
services/. - HTTP layer:
api/. - Settings:
core/. - Start script:
main.py.
Practical Guidelines for Structuring Python Backend Projects
To summarize the most important points:
Key rules for Python project structure
- Use a package layout
Put your code insideproject_name/with an__init__.pyfile. - Separate application code and tests
Application package (for examplemy_backend/) andtests/at the root. - Group by responsibility
For example: api/for routes and controllers.services/for business logic.models/for data models.core/orconfig.pyfor settings and core utilities.- Have a clear entry point
Create amain.pyor similar, and run it withpython -m package.module. - Centralize configuration
Read environment variables in a single settings module, and import that everywhere. - Declare dependencies
Userequirements.txtorpyproject.tomlso others can install your project easily.
If you follow these principles from the beginning, your backend projects will be much easier to grow, test, and maintain as you become a more advanced backend developer.
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!