25.8. Event-Driven Architecture
Table of Contents
Core Idea of Event-Driven Architecture
Event-driven architecture (EDA) is a way to build systems where events drive what happens, instead of direct calls between components.
In a classic request-response flow, Service A calls Service B and waits for the result. In event-driven architecture, Service A publishes an event such as "order.created", and any interested service subscribes to that event and reacts when it arrives.
You still use HTTP and REST, but many internal workflows become "when X happens, do Y" instead of "call Y from X".
At a high level, EDA is about:
- Events: Facts that happened in the system, like
"user.registered","payment.failed". - Producers: Components that emit events.
- Consumers: Components that listen and react to events.
- Event broker: A messaging system in the middle, such as Kafka, RabbitMQ, or Redis streams.
This style is very common in modern backends, especially in microservices, but it can also be used inside a single application or modular monolith.
Events: Facts, Not Commands
An event is a record of something that already happened, typically in the past tense.
Examples:
order.createdorder.paidorder.shippeduser.registeredpassword.changedproduct.out_of_stock
An event usually contains:
- Name / type:
"order.created" - ID: a unique event ID, such as a UUID
- Timestamp: when it happened
- Payload: data needed by consumers
Example JSON event:
{
"id": "b11f0f1c-2b59-4a0e-b6b5-03fd863a9e1c",
"type": "order.created",
"occurred_at": "2026-08-28T10:15:00Z",
"data": {
"order_id": "o_123",
"user_id": "u_45",
"total_amount": 99.50,
"currency": "USD",
"items": [
{"product_id": "p_10", "quantity": 1},
{"product_id": "p_11", "quantity": 2}
]
}
}Important rule: An event describes what happened, not what should happen. Use past tense, and avoid putting decisions into events.
This is different from a command, such as "send_invoice", which is a request to do something in the future. Commands are about intent, events are about facts.
Producers, Consumers, and the Message Broker
In an event-driven system, components have clear roles.
Producers
A producer is any component that emits events.
Typical producer examples:
- Order service publishes
"order.created"and"order.cancelled". - Payment service publishes
"payment.succeeded"and"payment.failed". - User service publishes
"user.registered"and"user.deleted".
Pseudocode example in Python:
def create_order(order_data, message_broker):
order = save_order_to_db(order_data)
event = {
"id": str(uuid4()),
"type": "order.created",
"occurred_at": datetime.utcnow().isoformat() + "Z",
"data": {
"order_id": order.id,
"user_id": order.user_id,
"total_amount": order.total_amount,
},
}
message_broker.publish("order.events", event)
return orderThe producer does not know who will consume the event.
Consumers
A consumer subscribes to events and reacts.
Typical consumer examples:
- Email service listens to
"user.registered"and sends welcome emails. - Inventory service listens to
"order.created"and reserves products. - Analytics service listens to many events and updates reports.
Pseudocode example:
def handle_order_created(event):
data = event["data"]
order_id = data["order_id"]
user_id = data["user_id"]
total = data["total_amount"]
send_invoice_to_user(user_id=user_id, order_id=order_id, total=total)
message_broker.subscribe("order.events", "order.created", handle_order_created)Here, the consumer also does not know who produced the event.
Message Broker
A message broker sits in the middle:
- Receives messages from producers.
- Delivers them to consumers.
- Often stores messages temporarily or longer.
- Handles queues, topics, offsets, and routing.
Common broker technologies:
| Broker | Typical style | Notes |
|---|---|---|
| RabbitMQ | Queues, routing | Popular for task queues and workers |
| Apache Kafka | Event streams | Great for high volume and replay |
| Redis | Pub/Sub, streams | Simple, often already in backend stack |
| AWS SNS/SQS | Topics + queues | Cloud managed, integrates with AWS services |
For this course you do not need broker internals yet, just the idea that your backend talks to a separate messaging system.
Event-Driven Flow vs Direct Calls
To understand EDA, compare a simple business flow written in two styles.
Direct, synchronous flow
Imagine an e-commerce store where:
- User places an order.
- System charges the credit card.
- If payment succeeds, emails a receipt and updates inventory.
Without events, your code might chain calls:
def place_order(order_data):
order = create_order_in_db(order_data)
payment_result = charge_payment(order)
if not payment_result.success:
mark_order_as_failed(order.id)
return
send_receipt_email(order)
update_inventory(order)
return order
The place_order function knows and controls every step.
Event-driven flow
With events, this may look like:
# Order service
def place_order(order_data, broker):
order = create_order_in_db(order_data)
event = {
"id": str(uuid4()),
"type": "order.created",
"occurred_at": datetime.utcnow().isoformat() + "Z",
"data": {"order_id": order.id, "user_id": order.user_id},
}
broker.publish("order.events", event)
return orderOther services own the next steps:
- Payment service consumes
"order.created", charges the card, and publishes"payment.succeeded"or"payment.failed". - Email service listens to
"payment.succeeded"and sends the receipt. - Inventory service listens to
"payment.succeeded"to reduce stock, and to"payment.failed"to release any reservation.
No single place has the whole flow hardcoded.
Publish/Subscribe Pattern
Event-driven architecture almost always uses the publish/subscribe pattern, often shortened to pub/sub.
- Publisher: sends a message to a topic such as
"order.events". - Subscriber: registers interest in one or more topics or event types.
The publisher does not list recipients. The broker does the routing.
A simple analogy:
- A news website posts an article on the site (publisher).
- Readers subscribe to categories like "Sports" or "Tech" (subscribers).
- The website does not need a separate list for each reader.
Pub/sub decouples:
- The number of consumers.
- The consumer implementation.
- The consumer deployment.
You can add a new analytics service that listens to "order.created" without touching the order service at all.
Event-Driven Architecture vs Synchronous APIs
Backend systems rarely choose only one style. You usually combine synchronous APIs and events.
Synchronous APIs
Use synchronous request-response when:
- The user is waiting for an answer.
- You need an immediate result, such as "is this password correct".
- The operation is small, fast, and local.
Examples:
POST /loginGET /productsGET /orders/{id}
Events
Use events when:
- Something happened and other parts of the system may react.
- Work can happen later or in the background.
- Different parts of the system should react independently.
Examples:
"user.registered"triggers:- Send welcome email.
- Add user to CRM.
- Start onboarding checklist.
"order.shipped"triggers:- Send tracking email.
- Update analytics.
Table comparison:
| Aspect | Request-response API | Event-driven |
|---|---|---|
| Direction | Client calls server | Producer publishes, consumers subscribe |
| Time | Synchronous, blocking | Asynchronous, non-blocking |
| Dependencies | Caller knows callee | Producers and consumers do not know each other |
| Typical protocol | HTTP, gRPC | Broker protocols (Kafka, AMQP, Redis) |
| Use cases | Read data, immediate actions | Reactions, notifications, background workflows |
In a FastAPI backend, for example, the public API is HTTP, but internally you may publish events to Redis or a queue for background workers.
Benefits of Event-Driven Architecture
EDA is popular because it solves several problems that appear as systems grow.
Loose coupling
Components do not call each other directly. They only:
- Emit events describing what they did.
- React to events they care about.
This means:
- You can change or replace a consumer without touching the producer.
- A producer can be written in a different language than the consumer.
- Services can be deployed separately.
Scalability
You can scale different consumers independently:
- If your email sending is slow, scale email consumer workers.
- If analytics is heavy, scale analytics consumers.
- The order service does not need to know or care.
Resilience
When you decouple with a broker, you can:
- Continue to accept orders even if email service is temporarily down. Events wait in a queue.
- Retry operations from events in case of transient errors.
- Sometimes replay events to rebuild a state.
Extensibility
You can add new behavior easily:
- Existing events like
"user.registered"already flow through the system. - You can build a new "referral rewards" service that listens to that event.
- No change is needed in the user registration logic.
Challenges and Trade-offs
EDA is not free. It brings complexity.
Eventual consistency
With events, not everything happens instantly in one transaction. Different parts of the system may be temporarily inconsistent.
Example:
- User places an order and gets back an order ID.
- A separate inventory service will reduce stock when it receives
"order.created"or"payment.succeeded". - For a small window of time, the product page might still show old stock numbers.
This is called eventual consistency.
Key idea: In event-driven systems, data is often eventually consistent, not instantly consistent across all services. Design your UX and workflows to accept short delays.
Debugging
When many services react to events, it can be hard to answer:
- "What exactly happened when this order was placed?"
- "Which service failed?"
You need good logging, correlation IDs, and tracing to follow events through the system.
Ordering and duplication
Many brokers cannot guarantee perfect ordering for all messages. Also, messages can sometimes be delivered more than once.
As a result, consumers should:
- Be idempotent: process the same event twice without bad side effects.
- Use event IDs or business keys to detect duplicates.
Example of idempotent consumer:
def handle_payment_succeeded(event):
event_id = event["id"]
if has_already_processed(event_id):
return # skip duplicate
data = event["data"]
order_id = data["order_id"]
if order_already_marked_as_paid(order_id):
return # another duplicate check
mark_order_as_paid(order_id)
record_processed_event(event_id)Schema evolution
Event payloads are a kind of API contract. Over time, you may need to:
- Add new fields.
- Deprecate old fields.
- Support multiple versions.
Changing event shape can break consumers, so you must be careful, similar to versioning REST APIs.
Common Event-Driven Patterns
Several patterns are frequently used in event-driven backends. You do not need to implement them now, but it is useful to recognize them.
Event notification
The simplest pattern: a service emits an event, but each consumer stores its own data and manages its own side effects.
Example:
"order.created"has basic info.- Listeners:
- Email service just sends emails.
- Analytics service updates stats.
- Logging service persists the raw event.
This is often enough for many workflows.
Event-carried state transfer
An event contains not only the ID of an entity, but also a snapshot of its important data. Consumers can update their own copies.
Example "product.price_changed":
{
"id": "e1",
"type": "product.price_changed",
"occurred_at": "2026-08-28T10:00:00Z",
"data": {
"product_id": "p_100",
"old_price": 19.99,
"new_price": 24.99,
"currency": "USD"
}
}A "search index" service can read this and update its own index without querying the product service.
Event sourcing (briefly)
In event sourcing, a service stores all events that affect an entity, and rebuilds the current state by replaying them. This is an advanced topic that overlaps with event-driven architecture, but you do not need to implement it for basic backend work.
The main idea is:
- Store events such as
"account.opened","money.deposited","money.withdrawn". - Derive current balance from the sequence of events.
For now, it is enough to know that some systems use events as the primary source of truth.
Practical Examples in a Backend
To make this concrete, imagine you are building the e-commerce backend from the later project chapters. Here is how EDA might show up.
User registration flow
When a user signs up:
- HTTP request hits
POST /users. - The user service:
- Validates and saves the user.
- Publishes
"user.registered"event. - Listeners:
- Email service sends welcome email.
- Analytics service logs a "new user" metric.
- Recommendation service prepares personalized content.
You can add or remove these listeners without changing the POST /users handler.
Order and payment flow
- Frontend calls
POST /orders. - Order service:
- Saves order in "pending" state.
- Publishes
"order.created". - Payment service:
- Listens to
"order.created". - Contacts payment gateway.
- Publishes
"payment.succeeded"or"payment.failed". - Order service listens to payment events and updates order status.
- Email and notification services listen to payment events and inform the user.
Here, the order service plays both producer and consumer roles for different events.
When to Use Event-Driven Architecture
You rarely start a very small project fully event-driven. EDA makes more sense when your system needs:
- Multiple independent reactions to one business event.
- Background processing that should not block user requests.
- Scalable and decoupled internal services.
- Extensibility without editing core workflows.
Examples of good fits:
- Sending emails, SMS, or push notifications in reaction to many actions.
- Updating analytics and reporting from live events.
- Processing long-running tasks such as:
- Video encoding.
- Document generation.
- Image processing.
- Synchronizing data to external systems or data warehouses.
Many systems start as a modular monolith with direct method calls and later introduce an event bus inside the monolith. Then, as parts are extracted into microservices, the events become network messages.
Summary
Event-driven architecture organizes your backend around events that describe what happened, not direct calls that tell others what to do.
You use:
- Producers to publish events.
- Consumers to react.
- A message broker to move events between them.
- Pub/sub to decouple who emits events from who listens.
The benefits are loose coupling, scalability, resilience, and easier extensibility, at the cost of eventual consistency and increased complexity. You still use synchronous HTTP APIs for many things, but internally, events can make your system more robust and flexible as it grows.
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!