4.12. Inheritance and Composition
Table of Contents
Why Inheritance and Composition Matter
When you work with object oriented programming, you often need to connect classes so they can reuse code and work together. Two major ways to do this are inheritance and composition.
Both are about reusing behavior and structuring your code, but they do it in very different ways:
- Inheritance: “is a” relationship
Example:Dogis aAnimal - Composition: “has a” relationship
Example:Carhas aEngine
Understanding the difference and when to use each will make your backend code cleaner, easier to change, and less buggy.
Key rule: Prefer composition over inheritance for flexibility. Use inheritance only when there is a clear, stable “is a” relationship.
We will use simple pseudo code that looks similar to Python or other C-like languages. The ideas are the same in most languages.
Inheritance
Basic Idea of Inheritance
With inheritance, you create a base class (also called parent or superclass) and then create child classes (subclasses) that extend it.
- The child class gets all the attributes and methods from the parent class.
- The child can add new behavior or override existing behavior.
Example:
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return "Some generic animal sound"
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow"Usage:
dog = Dog("Buddy")
cat = Cat("Misty")
print(dog.name) # Inherited attribute
print(dog.speak()) # "Woof!"
print(cat.speak()) # "Meow"Here:
DogandCatinheritnameand__init__fromAnimal.- They override
speak.
“Is a” Relationship
Use inheritance when you can clearly say:
ChildClassis aParentClass.
Examples that make sense:
Dogis anAnimalAdminUseris aUserPremiumAccountis anAccount
Examples that do not make sense:
Caris aEngine(wrong, car has an engine)Orderis aDatabaseConnection(wrong, order uses a database connection)
Rule: Only use inheritance when the subclass is a specialized version of the parent, not just because it needs similar behavior.
Why Inheritance Can Be Useful
Some typical backend examples:
Example 1: Common API Response Base
class ApiResponse:
def __init__(self, success, message):
self.success = success
self.message = message
class DataResponse(ApiResponse):
def __init__(self, data):
super().__init__(success=True, message="OK")
self.data = data
class ErrorResponse(ApiResponse):
def __init__(self, error_code, message):
super().__init__(success=False, message=message)
self.error_code = error_code
You reuse the shared fields success and message and specialize with data or error_code.
Example 2: Different Types of Users
class User:
def __init__(self, email):
self.email = email
def can_manage_system(self):
return False
class AdminUser(User):
def can_manage_system(self):
return True
AdminUser is still a User, but with different permissions.
Overriding Methods
A subclass can replace behavior:
class Payment:
def process(self, amount):
print("Processing generic payment of", amount)
class CreditCardPayment(Payment):
def process(self, amount):
print("Charging credit card for", amount)
class PayPalPayment(Payment):
def process(self, amount):
print("Charging PayPal for", amount)Usage:
payments = [
CreditCardPayment(),
PayPalPayment(),
]
for p in payments:
p.process(100)
This is polymorphism in action, but the important part here is that inheritance lets each subclass define its own process while still sharing the same interface.
Risks and Problems with Inheritance
Inheritance looks attractive, but it can cause issues:
- Tight coupling
The child class depends heavily on the parent. If the parent changes, many children may break. - Inflexible structure
A class can only inherit from one main parent (in many languages) and getting behavior from multiple sources becomes complex. - Wrong relationships
Developers sometimes use inheritance just to reuse code even when “is a” is not true. - Deep inheritance trees
When you haveClassA -> ClassB -> ClassC -> ClassD, it becomes hard to understand where behavior comes from.
Example of a bad inheritance design:
class DatabaseLogger:
def log(self, message):
print("Saving to DB:", message)
class User(DatabaseLogger):
def __init__(self, email):
self.email = email
User is not a DatabaseLogger. It might use logging, but it should not be a logger. This is a hint that another pattern, usually composition, is better.
Composition
Basic Idea of Composition
With composition, you build objects by combining other objects as attributes. Instead of “is a”, you create “has a” relationships.
- A class can contain instances of other classes.
- You can change parts easily, since they are separate components.
Example:
class Engine:
def start(self):
print("Engine started")
class Car:
def __init__(self, engine):
self.engine = engine
def drive(self):
self.engine.start()
print("Car is moving")Usage:
engine = Engine()
car = Car(engine)
car.drive()
Car has an Engine. That matches the real world and is easy to understand.
“Has a” Relationship
Use composition when you can say:
ClassAhas aClassB.
Examples that make sense:
Orderhas aCustomerCarthasCartItemsUserServicehas aUserRepositoryEmailSenderhas anSmtpClient
Examples:
class Customer:
def __init__(self, name):
self.name = name
class Order:
def __init__(self, order_id, customer):
self.order_id = order_id
self.customer = customerHere the order object keeps a customer object inside it.
Composition in Backend Code
Example 1: Service Uses Repository
In backend applications you often separate business logic from data access.
class UserRepository:
def find_by_email(self, email):
# query DB
pass
def save(self, user):
# insert or update in DB
pass
class UserService:
def __init__(self, user_repository):
self.user_repository = user_repository # composition
def register_user(self, email, password):
existing = self.user_repository.find_by_email(email)
if existing:
raise Exception("User already exists")
# create and save new user
self.user_repository.save({"email": email, "password": password})
UserService has a UserRepository. It does not inherit from it.
Example 2: Controller Uses Service
class UserController:
def __init__(self, user_service):
self.user_service = user_service
def post_register(self, request_body):
email = request_body["email"]
password = request_body["password"]
self.user_service.register_user(email, password)
return {"status": "ok"}
UserController has a UserService. This is composition again.
Example 3: Logger as a Component
class Logger:
def info(self, message):
print("[INFO]", message)
class PaymentService:
def __init__(self, logger):
self.logger = logger
def create_payment(self, amount):
self.logger.info(f"Creating payment for {amount}")
# business logic
PaymentService has a Logger. You can swap the logger later with a different implementation if needed.
Why Composition Is Usually Better
Composition provides:
- Flexibility
You can change combined parts without touching other code. - Looser coupling
Components depend on interfaces, not concrete parent classes. - Reusability
A component (for exampleLogger) can be used by many other classes. - Simpler structure
You avoid deep inheritance trees and keep class relationships clearer.
Example of flexible composition:
class ConsoleLogger:
def info(self, message):
print("[INFO]", message)
class FileLogger:
def __init__(self, file_path):
self.file_path = file_path
def info(self, message):
with open(self.file_path, "a") as f:
f.write("[INFO] " + message + "\n")
class OrderService:
def __init__(self, logger):
self.logger = logger
def create_order(self, data):
self.logger.info("Creating order")
# create orderUsage:
service1 = OrderService(ConsoleLogger())
service2 = OrderService(FileLogger("orders.log"))
Same OrderService code, different logger implementations. No inheritance needed.
Inheritance vs Composition
Comparing the Two
| Aspect | Inheritance | Composition |
|---|---|---|
| Relationship type | “is a” | “has a” |
| Code reuse style | Share and override parent behavior | Combine behaviors of separate objects |
| Coupling | Tighter coupling to parent | Looser coupling, more flexible |
| Flexibility | Harder to change parent without side effects | Easier to swap or modify components |
| Typical use case | Variants of the same concept | Building complex objects from simple parts |
| Number of parents | Usually one main parent | Many components can be used together |
| Risk | Misused for code reuse, deep hierarchies | More objects to manage, but clearer structure |
Examples: Same Problem, Two Approaches
Scenario: Users with Notifications
You need users that can receive notifications by email and maybe later by SMS.
Using Inheritance (less ideal here)
class User:
def __init__(self, email):
self.email = email
def notify(self, message):
print(f"Sending email to {self.email}: {message}")
class SmsUser(User):
def __init__(self, email, phone):
super().__init__(email)
self.phone = phone
def notify(self, message):
print(f"Sending SMS to {self.phone}: {message}")Problems:
- What if you want SMS and email?
- Do you create another subclass?
EmailAndSmsUser? - The number of subclasses grows quickly.
Using Composition (more flexible)
class EmailNotifier:
def notify(self, user, message):
print(f"Email to {user.email}: {message}")
class SmsNotifier:
def notify(self, user, message):
print(f"SMS to {user.phone}: {message}")
class User:
def __init__(self, email, phone=None, notifiers=None):
self.email = email
self.phone = phone
self.notifiers = notifiers or []
def send_notifications(self, message):
for notifier in self.notifiers:
notifier.notify(self, message)Usage:
email_user = User(
email="a@example.com",
notifiers=[EmailNotifier()]
)
sms_and_email_user = User(
email="b@example.com",
phone="+123",
notifiers=[EmailNotifier(), SmsNotifier()]
)
email_user.send_notifications("Welcome!")
sms_and_email_user.send_notifications("Welcome!")Here:
Userhas a list of notifiers.- You can add or remove notifier types without creating new subclasses.
Common Patterns in Backend with Composition
Services, Repositories, and Clients
Backend applications often follow patterns that rely heavily on composition.
Typical stack for a feature:
ControllerorRouteruses aServiceServiceuses one or moreRepositoriesServicemay also use external APIClients- Components may use a shared
Logger,Cache, orConfig
Example:
class CacheClient:
def get(self, key):
pass
def set(self, key, value):
pass
class ProductRepository:
def __init__(self, db_connection):
self.db = db_connection
def find_by_id(self, product_id):
# query DB
pass
class ProductService:
def __init__(self, repository, cache):
self.repository = repository
self.cache = cache
def get_product(self, product_id):
cached = self.cache.get(product_id)
if cached:
return cached
product = self.repository.find_by_id(product_id)
if product:
self.cache.set(product_id, product)
return productComposition lets you plug in different implementations:
- A
MemoryCacheClientorRedisCacheClient - A
MockProductRepositoryfor tests
All without inheritance.
Adapter Style Classes
Sometimes you need to make two parts of your code work together.
Example: wrapping a low-level HTTP client:
class HttpClient:
def get(self, url):
# low level HTTP call
pass
class WeatherApiClient:
def __init__(self, http_client):
self.http_client = http_client
def get_forecast(self, city):
url = f"https://example.com/weather?city={city}"
response = self.http_client.get(url)
# parse response
return response
WeatherApiClient has an HttpClient. This is composition again.
When to Choose Inheritance
Even though composition is usually preferred, there are still valid cases for inheritance.
Use inheritance when:
- You really have a hierarchy of types.
- You want polymorphic behavior where each subclass behaves differently but shares the same interface.
- The base class defines a contract or template that subclasses fill in.
Examples:
- Different types of payments:
class Payment:
def process(self, amount):
raise NotImplementedError
class CreditCardPayment(Payment):
def process(self, amount):
# process card
class BankTransferPayment(Payment):
def process(self, amount):
# process bank transfer- Different types of queries in a query builder, or different shapes for error types that share a base error.
Guideline:
Use inheritance for type hierarchies and polymorphism,
use composition to combine behaviors and build larger objects from smaller pieces.
Practical Exercises to Cement Understanding
Try these small exercises mentally or in your language of choice.
Exercise 1: Fix Bad Inheritance
Given:
class DatabaseConnection:
def connect(self):
print("Connecting to DB")
class User(DatabaseConnection):
def __init__(self, email):
self.email = email
Question:
Refactor this using composition instead of inheritance.
Possible solution:
class DatabaseConnection:
def connect(self):
print("Connecting to DB")
class UserRepository:
def __init__(self, db_connection):
self.db_connection = db_connection
def find_by_email(self, email):
self.db_connection.connect()
# query DB
return {"email": email}
The User object should not extend DatabaseConnection. A separate UserRepository that has a DatabaseConnection is better.
Exercise 2: Add Behavior With Composition
You have:
class Order:
def __init__(self, items):
self.items = items # list of (name, price)
Add a separate component that can calculate the total price, and use composition instead of adding all logic inside Order.
Possible solution:
class PriceCalculator:
def calculate_total(self, items):
return sum(price for name, price in items)
class Order:
def __init__(self, items, calculator):
self.items = items
self.calculator = calculator
def total(self):
return self.calculator.calculate_total(self.items)Summary
- Inheritance lets one class extend another. Use it when there is a clear “is a” relationship and you need polymorphic behavior.
- Composition builds a class by combining other classes. Use it when there is a “has a” relationship or when you want flexible code reuse.
- Backend code, especially services, repositories, controllers, and clients, usually benefits more from composition than from complex inheritance trees.
- By choosing the right relationship between your classes, you make your backend code easier to understand, test, and change.
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!