4.8. Modules and Packages
Table of Contents
Why Modules and Packages Matter
As your programs grow, keeping all code in a single file becomes messy and hard to maintain. You need a way to:
- Split code into multiple files.
- Reuse code across projects.
- Organize related functionality together.
This is what modules and packages are for. They are about organizing and reusing code, not about learning a new kind of logic.
In this chapter we focus on the concepts, with examples in a Python-like style, because later you will use this directly in real Python backend projects.
Modules
A module is simply one file that contains Python code.
If you have a file named:
math_utils.py
then math_utils is a module.
Inside that file you might have functions, classes, and variables:
# math_utils.py
PI = 3.14159
def add(a, b):
return a + b
def circle_area(radius):
return PI * radius * radiusYou can then import and use this module from another file:
# main.py
import math_utils
result = math_utils.add(2, 3)
print(result) # 5
print(math_utils.PI) # 3.14159The key ideas:
- One
.pyfile is one module. - The module name is the file name without
.py. - You access things inside the module with
module_name.something.
Why Use Modules?
Imagine a small backend project:
auth.pyfor authentication logic.db.pyfor database access.utils.pyfor helper functions.main.pyas the entry point of the application.
This separation gives you:
- Organization: Each file has a clear responsibility.
- Reusability: You can reuse, for example,
db.pyin another project. - Testability: Easier to write tests for each part.
Example structure:
project/
main.py
auth.py
db.py
utils.py
In main.py you could write:
import auth
import db
def start_app():
db.connect()
auth.setup_auth()Importing Modules
There are several common ways to import modules. Understanding them is crucial because you will see them constantly in backend code.
`import module`
This is the most basic form.
import math_utils
print(math_utils.add(1, 2))- You get the whole module.
- You use the module name as a prefix.
`import module as alias`
Use an alias to shorten long names:
import math_utils as mu
print(mu.add(1, 2))This is common with popular libraries:
import numpy as np
import pandas as pd`from module import name`
If you only need specific items:
from math_utils import add, circle_area
print(add(1, 2))
print(circle_area(5))- You do not use the module prefix.
- Only the imported names are available.
`from module import *` (and why to avoid it)
from math_utils import *This imports everything, which looks convenient but is dangerous in larger projects.
Rule: Avoid from module import * in real projects.
It makes it unclear where names come from and can cause name conflicts.
Python’s Standard Library vs Your Own Modules
You will often import:
- Standard library modules, for example
os,sys,json,datetime. - Third-party modules, installed via
pip, for examplerequests,fastapi. - Your own modules, for example
auth,db,utils.
Example:
import os # standard library
import fastapi # third-party
import utils # your own moduleThe import syntax is the same. Only the source of the module changes.
Packages
A package is a directory that groups related modules.
Minimal Python package structure:
my_app/
__init__.py
auth.py
db.py
utils.pymy_appis a package.auth.py,db.py,utils.pyare modules inside that package.__init__.pytells Python thatmy_appis a package.
In modern Python versions, __init__.py is not always required, but you will see it a lot and it is still common practice, especially in backend projects.
You can import like this:
import my_app.auth
from my_app import db
from my_app.utils import format_dateNested Packages
Packages can contain subpackages, which are packages inside packages.
Example:
shop/
__init__.py
auth/
__init__.py
login.py
register.py
orders/
__init__.py
create.py
list.py
products/
__init__.py
catalog.pyHere:
shopis a top-level package.shop.auth,shop.orders,shop.productsare subpackages.shop.auth.loginis a module inside theauthsubpackage.
You can import like this:
from shop.auth.login import login_user
from shop.orders.create import create_order
import shop.products.catalog as catalogThis style is very typical for backend projects: group related functionality in subpackages.
Absolute vs Relative Imports
In a package, you have two main ways to import:
- Absolute imports
- Relative imports
Absolute Imports
Use the full path from the project root.
Example project:
my_project/
main.py
shop/
__init__.py
auth/
__init__.py
login.py
tokens.py
db/
__init__.py
connection.py
Inside shop/auth/login.py:
# absolute import
from shop.db.connection import get_db
from shop.auth.tokens import create_token- Start from the top-level package
shop. - This is clear and explicit.
Relative Imports
Relative imports use dots to say "from my current package".
Rules:
.means "current package"...means "parent package"....means "parent of parent", and so on.
Inside shop/auth/login.py you can write:
# relative imports
from .tokens import create_token # from the same package 'auth'
from ..db.connection import get_db # from sibling package 'db'Both absolute and relative imports are used in real projects.
Guideline:
Use absolute imports for clarity across the project.
Use relative imports carefully inside packages, usually only when it makes the structure easier to change.
Example: Organizing a Simple Backend
Imagine a tiny backend with:
- User registration and login.
- Database access.
- Some utilities.
Structure:
backend/
__init__.py
main.py
auth/
__init__.py
register.py
login.py
db/
__init__.py
connection.py
models.py
utils/
__init__.py
hashing.py
validators.pySome example module contents:
db/connection.py:
# db/connection.py
def get_db():
print("Connecting to database...")
# return a fake connection for demo
return "db_connection"
auth/register.py:
# auth/register.py
from ..db.connection import get_db
from ..utils.hashing import hash_password
from ..utils.validators import is_valid_email
def register_user(email, password):
if not is_valid_email(email):
raise ValueError("Invalid email")
db = get_db()
password_hash = hash_password(password)
print(f"Saving user {email} with hash {password_hash} to {db}")
utils/hashing.py:
# utils/hashing.py
def hash_password(password: str) -> str:
return f"HASHED::{password}"
utils/validators.py:
# utils/validators.py
def is_valid_email(email: str) -> bool:
return "@" in email and "." in email
main.py:
# main.py
from backend.auth.register import register_user
def main():
register_user("user@example.com", "secret123")
if __name__ == "__main__":
main()This demonstrates:
- Folder structure that matches logical parts of the backend.
- Imports across packages and modules.
- Separation of responsibilities.
Reusing Code with Modules and Packages
Modules and packages allow you to reuse code in multiple places:
- A
hash_passwordfunction inutils/hashing.pycan be used by: - Registration logic.
- Login logic.
- Password reset logic.
Example:
# auth/login.py
from ..db.connection import get_db
from ..utils.hashing import hash_password
def login_user(email, password):
db = get_db()
hashed = hash_password(password)
print(f"Checking user {email} with hash {hashed} in {db}")Instead of copying the hashing logic three times, you put it in one module and import it everywhere.
Important:
Do not copy and paste the same code into multiple files.
Put shared logic into a module, then import it where needed.
This is a core habit for professional backend development.
Avoiding Circular Imports
A circular import happens when:
- Module A imports module B.
- Module B imports module A.
Python loads modules once, in order. If module A tries to import B, and B tries to import A at the same time, you can get errors.
Example of a problem:
auth/login.py:
from auth.session import create_session
def login():
# ...
create_session()
auth/session.py:
from auth.login import login # circular dependency
def create_session():
# ...
login()
Here login.py imports session.py and session.py imports login.py.
This is a circular import.
How to avoid circular imports
- Refactor shared logic into a third module:
auth/
__init__.py
login.py
session.py
helpers.py
Move common functions to helpers.py, then have both login.py and session.py import helpers, instead of importing each other.
- Import inside a function, not at the top (as a last resort):
# session.py
def create_session():
from auth.login import login # local import
# use login here
This delays the import until the function is called, which can work around some circular dependencies.
Prefer refactoring over this when possible, because it is clearer.
`__init__.py` and Package Initialization
The file __init__.py is executed when the package is imported.
For example, in backend/utils/__init__.py:
# backend/utils/__init__.py
print("Initializing backend.utils package")
from .hashing import hash_password
from .validators import is_valid_email
__all__ = ["hash_password", "is_valid_email"]Now when someone does:
from backend import utils- The
printin__init__.pywill execute once. - They can access:
utils.hash_password("secret")Also:
from backend.utils import *
will import only the names listed in __all__. This is one reason __init__.py is still useful.
Naming and Organization Best Practices
For backend projects, clear structure is critical.
File and module naming
- Use lowercase file names:
auth.py, notAuth.py. - Use underscores for multiple words:
user_service.py. - Give descriptive names:
db_connection.pyis better thana1.py.
Package design
Group modules by their purpose:
Typical backend layout:
app/
__init__.py
main.py # application entry point
config.py # configuration
api/ # API route handlers
__init__.py
users.py
auth.py
products.py
services/ # business logic
__init__.py
user_service.py
order_service.py
db/ # database-related code
__init__.py
models.py
connection.py
utils/ # helper functions
__init__.py
hashing.py
email_utils.pyYou will see similar structures in many backend frameworks.
Examples You Can Try Yourself
To practice, create a small project like:
calculator/
main.py
operations/
__init__.py
add.py
subtract.py
multiply.py
divide.py
operations/add.py:
def add(a, b):
return a + b
operations/subtract.py:
def subtract(a, b):
return a - b
main.py:
from operations.add import add
from operations.subtract import subtract
def main():
print(add(5, 3))
print(subtract(5, 3))
if __name__ == "__main__":
main()Then extend this structure, for example:
- Add
operations/advanced/power.py. - Add
operations/advanced/root.py. - Use nested imports like
from operations.advanced.power import power.
This is the same skill you will use later to organize real backend applications.
Summary
- A module is a single
.pyfile. - A package is a directory that contains modules, often with
__init__.py. - Use
import moduleorfrom module import nameto reuse code. - Organize code in packages and subpackages by responsibility, such as
auth,db,utils,api. - Prefer absolute imports for clarity, use relative imports carefully inside packages.
- Avoid circular imports by refactoring shared logic into separate modules.
- Use good naming and structure to keep backend projects understandable and maintainable.
You now have the conceptual tools to structure real-world backend code as your projects grow.
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!