4.10. Object-Oriented Programming
Table of Contents
Why Object Oriented Programming Matters
Most backend codebases are written using Object Oriented Programming, often shortened as OOP. As an absolute beginner, you do not need to become an OOP expert immediately, but you do need to understand what it is, why it exists, and how it changes the way you think about programs.
In earlier chapters, you saw programs as a set of variables and functions that work on data. With OOP, you start to group related data and behavior together into units called objects. This way of organizing code becomes very powerful in large backend systems.
This chapter gives you the big picture of OOP. Detailed syntax and language specifics will come later when you learn about classes and objects, inheritance, and other OOP topics in more depth.
From “Data + Functions” to “Objects”
Procedural Style: Data and Functions Are Separate
In a procedural style, you often have data stored in simple structures, and you write functions that operate on that data.
Imagine you are building a very small task management script. You might write something like this, in a Python-like pseudocode:
task_title = "Write documentation"
task_completed = False
def complete_task():
global task_completed
task_completed = True
def print_task():
status = "done" if task_completed else "pending"
print(f"{task_title} [{status}]")
print_task() # Write documentation [pending]
complete_task()
print_task() # Write documentation [done]Here:
- Data is in
task_titleandtask_completed. - Behavior is in
complete_taskandprint_task. - They belong together conceptually, but they are separate in the code.
This is fine for tiny scripts. For real backend applications with hundreds of related pieces of data and behavior, it becomes messy and hard to maintain.
Object Oriented Style: Data and Behavior Together
In OOP, you think in terms of objects that represent entities in your system.
For the same task example, you would create a Task object that contains both the task data and the operations on that data:
task = Task(title="Write documentation")
task.print() # Write documentation [pending]
task.complete()
task.print() # Write documentation [done]You do not need separate global variables or functions. Instead, you have:
- A
Tasktype (a class) that defines what a task is and what it can do. - A
taskinstance (an object) that holds the actual data for one specific task.
This grouping of data + behavior inside a single unit is at the heart of OOP.
The Core Ideas Behind OOP
OOP has four commonly mentioned core ideas:
- Encapsulation
- Abstraction
- Inheritance
- Polymorphism
You will explore these ideas more deeply in related chapters, but you should understand what they mean conceptually now.
Encapsulation: Keeping Related Things Together
Encapsulation means grouping related data and the functions that work on that data into a single unit, and controlling access to that unit.
In simple terms:
- Data belongs to an object.
- Functions that use that data, called methods, live inside the object.
- Outside code usually talks to the object through a clear interface.
Example in a backend context: a User object.
Instead of:
user_name = "alice"
user_password_hash = "..."
def check_password(stored_hash, password_attempt):
# logic
...
You encapsulate this in a User object:
user = User(username="alice")
if user.check_password("password123"):
print("Login ok")
else:
print("Wrong password")Here:
- The user data (like
username, password hash, etc.) is inside theUserobject. - The logic to check a password is also inside that object.
- Outside code just calls
user.check_password(...)and does not need to know how password checking works internally.
Encapsulation helps you:
- Keep related code together.
- Avoid global variables.
- Change the internal implementation without breaking code that uses the object.
Abstraction: Focusing on What, Not How
Abstraction means hiding complex details and exposing only what other code needs to know.
From the outside, you care about what an object can do, not how it does it.
Backend example: sending emails.
Consider this simple interface:
email_client.send(
to="user@example.com",
subject="Welcome",
body="Thanks for registering!"
)
The code that calls email_client.send does not need to know:
- Which SMTP server is used.
- How authentication to the email server works.
- How retry logic is implemented.
All of that complexity is hidden inside the EmailClient object.
Abstraction is not only about objects. You also abstract through functions, modules, and packages. But OOP encourages you to build abstractions around real-world concepts like User, Order, Cart, Repository, EmailClient, and many more.
Key abstraction rule: Design objects so that other parts of the system can use them by reading a small, clear public interface and without needing to understand the internal details.
Inheritance: Reusing and Extending Behavior
Inheritance lets you create a new class that reuses and specializes another class.
Example: a simple payment system for an e-commerce backend.
You might have a base concept:
PaymentMethodThen concrete types:
CreditCardPayment
PayPalPayment
BankTransferPaymentConceptually:
- All payment methods share common data and behavior, such as
amount,currency, a methodpay(), and status likepending,completed,failed. - Each specific payment method adds or overrides some behavior.
In OOP terms:
PaymentMethodis a base class or parent class.CreditCardPayment,PayPalPayment, andBankTransferPaymentare derived classes or child classes.
You reuse common logic in the parent class, and children add or refine logic.
You will study inheritance in detail in a dedicated chapter. For now, remember the purpose: remove duplication and capture shared behavior in a common parent.
Polymorphism: One Interface, Many Implementations
Polymorphism means "many forms." In OOP, it is the idea that different objects can be used through the same interface, even though they implement the behavior in different ways.
Using the same payment example, you might write code like:
def process_payment(payment_method):
payment_method.pay()
payment_method.send_receipt()
Now process_payment can receive any payment object that understands pay() and send_receipt():
CreditCardPaymentPayPalPaymentBankTransferPayment
process_payment does not care which specific class it is. It just trusts that the object follows the expected interface.
This is very powerful in backend systems, because you can:
- Swap implementations without changing the calling code.
- Plug in new behaviors (like new payment providers) by adding new classes that follow the same interface.
Later, in language-specific chapters, you will see how polymorphism is implemented and used in practice.
Thinking in Objects: Modeling Real Backend Problems
A big shift when learning OOP is changing how you model problems.
Instead of asking, "What functions do I need?" you ask, "What objects does my system have, and what should they be able to do?"
Let us look at a few backend examples.
Example 1: Simple User Management
Imagine a simple user system:
- Users register.
- Users can log in.
- Users have roles, like
"user"or"admin".
You might think about the following objects:
| Concept | Possible Class Name | Example Responsibilities |
|---|---|---|
| A user | User | Store username, password hash, role. |
| Auth service | AuthService | Register, log in, validate tokens. |
| User storage | UserRepository | Load and save users in the database. |
Now you can express operations like:
user = auth_service.register(username, password)
logged_in_user = auth_service.login(username, password)
user_repo.save(user)Here, each object has a clear responsibility, and your logic is split across these objects, not in one giant script.
Example 2: Todo List API
Consider a simple backend for a todo list application.
Key concepts:
- Users
- Tasks
- Lists
You might create:
| Concept | Possible Class Name | Example Responsibilities |
|---|---|---|
| A user | User | User data, user-specific logic. |
| A task | Task | Task data, mark as done, set due date. |
| A list | TaskList | Contains multiple tasks, add/remove tasks, etc. |
| Storage | TaskRepository | Interact with database for tasks. |
| API layer | TaskController | Receive HTTP requests, call services or repositories. |
Example flow in code-like thinking:
# In a controller handling "POST /tasks"
task = Task(title="Buy milk", owner=user)
task_repo.save(task)
return task.to_dict()Again, you see how objects represent entities and operations in your system.
Objects, Classes, and Instances
OOP talks a lot about three words:
- Class
- Object
- Instance
These are related but not the same.
Class: The Blueprint or Template
A class is a definition of what an object of a certain type looks like and what it can do.
Think of a class as a blueprint for building houses:
- A house blueprint describes the number of rooms, windows, doors, etc.
- It also describes where things are.
- But the blueprint is not a house.
Similarly, a class describes:
- Which pieces of data an object has.
- Which methods (functions) it exposes.
Backend example: a user blueprint:
class User:
data: username, email, password_hash, role
methods: check_password, change_password, is_adminThat is the "recipe" for building user objects.
Object: The Actual Thing in Memory
An object is one concrete thing that was built using a class.
Using the house analogy again:
- The class is the house blueprint.
- Each real house you can walk into is an object.
In code:
alice = User(username="alice@example.com")
bob = User(username="bob@example.com")Here:
Useris the class.aliceis an object of classUser.bobis another object of classUser.
They share the same blueprint but hold different data.
Instance: An Object of a Specific Class
The word instance is usually used as "instance of a class."
For example:
aliceis an instance ofUser.bobis an instance ofUser.
"Object" and "instance" are often used interchangeably, but "instance" emphasizes that this object belongs to a specific class.
You will see phrases like:
- "Create an instance of
User." - "This method returns a
Taskinstance."
They all describe concrete objects in memory.
State and Behavior
At the simplest level, an object has:
- State: the data it holds at a given time.
- Behavior: the operations (methods) it can perform.
State: Data Stored in the Object
Backend example: a Session object in an authentication system.
Its state might include:
user_idcreated_atexpires_atip_addressuser_agentis_active
At runtime, for a particular user:
Session(
user_id=42,
created_at="2026-08-27T12:00:00Z",
expires_at="2026-08-27T14:00:00Z",
ip_address="192.0.2.10",
user_agent="Mozilla/5.0",
is_active=True
)All of that is "inside" one object.
Behavior: Methods That Operate on the State
The same Session object might have methods like:
is_expired()invalidate()extend(duration)matches_request(ip, user_agent)
When you call these methods, they use and modify the internal state.
Example sequence:
session.is_expired() # checks created_at and expires_at
session.extend(3600) # updates expires_at
session.invalidate() # sets is_active to FalseThe idea is that you do not manually manipulate small pieces of state from outside. Instead, you call meaningful methods on the object itself.
Important OOP habit: Modify an object's state through its methods, not by randomly changing its internal variables from outside.
This keeps your code safer and more predictable.
Responsibilities and Design
A large part of OOP is about deciding what each class should be responsible for.
If you give a class too many responsibilities, it becomes huge and hard to change. If you give it too few, you end up with many tiny classes that are hard to understand.
A good rule of thumb, related to clean code principles, is:
Single Responsibility Idea: Each class should have one main reason to change, which usually corresponds to one clear responsibility.
Examples in a backend:
UserRepositoryis responsible only for saving and loading users from a database, not for sending emails or handling HTTP.EmailServiceis responsible only for sending emails, not for validating passwords.AuthServiceis responsible for login, logout, token creation, and related user authentication logic.
Separating responsibilities across different classes helps you:
- Test pieces individually.
- Replace or update one part without breaking others.
- Avoid huge "god classes" that try to do everything.
How OOP Shows Up in Backend Projects
You might be wondering where you will actually see OOP in backend development. Here are some places and patterns you will encounter again and again.
Domain Models
Most backends represent a "domain" such as:
- E-commerce
- Banking
- Social networking
- Task management
You will often create domain model classes that reflect real entities in that domain, such as:
User,Product,Order,Cart,PaymentAccount,Transaction,TransferPost,Comment,Like,Follow
These classes usually:
- Hold data that will also be stored in the database.
- Contain domain logic, such as calculation of totals, checking if an operation is allowed, or changing status.
Example for an order:
class Order:
data: items, status, user, created_at
methods: add_item, remove_item, total_price, complete, cancelData Access Layers
You usually do not have your controllers directly writing SQL queries everywhere. Instead, you put database logic into special classes, often called repositories.
Examples:
UserRepositoryOrderRepositoryTaskRepository
These objects provide methods like:
find_by_idsavedeletefind_all_for_user
You will see this again when you learn about ORMs and the repository pattern.
Services
A service is a class that coordinates operations between different parts of the system.
Examples:
AuthServiceinteracts withUserRepository, password hashing utilities, and token generators.OrderServiceinteracts withOrderRepository,PaymentService, andInventoryService.
Service classes often:
- Use several domain models and repositories.
- Contain more complex business workflows.
- Are stateless or almost stateless. They focus on behavior more than on internal data.
Examples: Procedural vs OOP Style in Backends
To better understand OOP, compare a procedural-style backend snippet to an object-oriented one.
Example: Simple Login Flow
Procedural Style
def get_user_by_username(db, username):
# run SQL
...
def verify_password(stored_hash, password):
# check hash
...
def login(db, username, password):
user = get_user_by_username(db, username)
if not user:
return None
if not verify_password(user["password_hash"], password):
return None
session_token = create_session_token(user["id"])
save_session(db, user["id"], session_token)
return session_tokenEverything is functions and dictionaries (or other data structures). There is nothing wrong with this for small code, but it does not scale nicely.
Object Oriented Style
With OOP, you might have:
- A
Userclass. - A
UserRepository. - An
AuthService. - A
SessionManager.
Conceptual code:
user = user_repo.find_by_username(username)
if not user:
return None
if not user.check_password(password):
return None
session = session_manager.create_session(user)
return session.tokenHere is what changed conceptually:
- Password verification moved into the
Userobject, so it knows how to check its own password. - Session creation moved into a
SessionManagerobject. - The login workflow moved into an
AuthServiceobject.
Your code is now expressed in terms of objects that correspond to the concepts in your system. This often makes it easier to read and maintain.
When OOP Helps and When It Can Hurt
OOP is very useful, but it is not magic. It can also be overused.
Where OOP Helps
OOP is especially helpful when:
- Your application has many related entities and workflows.
- You want to reflect real-world concepts and business rules in your code.
- You want your code to be modular and testable.
- You expect your project to grow and change over time.
Backend applications with users, orders, payments, permissions, and so on, typically benefit a lot from OOP structures.
Where OOP Can Hurt
OOP can cause trouble when:
- You create too many small classes that only pass data around without real behavior, which can make code harder to follow.
- You create deep inheritance hierarchies that are difficult to understand and modify.
- You hide too much, which makes debugging difficult.
The goal is balance. Use classes when they help you model your domain, and keep them simple and focused.
Summary
In this chapter, you learned the foundational ideas behind Object Oriented Programming:
- You group data and behavior together into objects.
- A class is the blueprint, and an instance (or object) is a concrete realization of that blueprint.
- Objects have state (data) and behavior (methods).
- OOP relies on four core ideas:
- Encapsulation groups related data and behavior.
- Abstraction hides internal complexity behind a simple interface.
- Inheritance allows reuse and specialization of behavior.
- Polymorphism lets different objects be used through the same interface.
- In backends, you use OOP to model users, tasks, orders, payments, and many other entities, as well as repositories, services, and other layers.
In the next chapters, you will dive deeper into classes and objects, inheritance and composition, and clean code principles, where you will see how these ideas are expressed in real code and how they guide the structure of backend applications.
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!