25.9. Choosing an Architecture
Table of Contents
Big Picture: What “Architecture” Really Means
When people say “backend architecture,” they are talking about how you organize your code and services so that:
- It is easy to change.
- It can handle more users later.
- It is safe and reliable.
- It is understandable to humans.
You have already seen different styles like monoliths, modular monoliths, microservices, layered architecture, service layer, repository pattern, and domain driven design basics. This chapter is about how to choose between these options for a real project.
Architecture is never “one size fits all.” It always depends on your project context.
Important rule: There is no “best architecture” in general. There is only “best architecture for this specific problem, with these constraints, at this time.”
In this chapter you will learn how to think about those constraints and turn them into a clear decision.
Key Criteria When Choosing an Architecture
The main dimensions to evaluate
When you choose an architecture, you are trading between several qualities:
| Quality | What it means in practice |
|---|---|
| Simplicity | Easy to understand, develop, and debug |
| Development speed | How fast you can build and ship features |
| Scalability | How well the system handles more users and data |
| Reliability | How well the system handles failures |
| Maintainability | How easy it is to change code over time |
| Testability | How easy it is to write and run automated tests |
| Performance | Speed of responses and resource usage |
| Team fit | Fits team skills, size, and experience |
| Operational overhead | How much effort it takes to deploy, monitor, and operate in production |
| Flexibility | How easily you can add new features or change existing ones |
| Cost | Money and time required to build and run the system |
You cannot maximize everything at once. For a small project, simplicity and speed usually win. For a big company with millions of users, scalability and reliability become more important.
Matching Architecture to Project Size and Complexity
A simple rule of thumb
You can often start with a rule like this:
| Project size / complexity | Recommended starting architecture |
|---|---|
| Small toy apps, prototypes, personal tools | Simple monolith, minimal layers |
| Small startup product, early MVP | Monolith, light layering |
| Growing product, many features, multiple devs | Modular monolith with clear boundaries |
| Very large product, many independent teams | Microservices or hybrid architecture |
Heuristic: Start simple. Only move to more complex architectures when the pain of your current design is clearly higher than the cost of moving.
Example: Personal to-do list app
- 1 developer.
- Few features.
- Low traffic.
- Goal: Learn and ship something.
Best fit: Monolithic app with a simple layered structure. Microservices would only add complexity without benefit.
Example: Growing B2B SaaS with 10 developers
- Many features: billing, projects, teams, reporting.
- 10 developers, several squads.
- Medium traffic.
Best fit: Modular monolith at first, with clear modules like billing, projects, users. Maybe split out 1 or 2 services later if needed.
Example: Global marketplace with hundreds of developers
- Many independent areas: search, payments, logistics, reviews.
- Many teams, different deployment cadences.
- High traffic, strict reliability and compliance needs.
Best fit: Microservices or service oriented architecture, because team boundaries and scale dominate the decision.
When to Use a Monolithic Architecture
Characteristics of a monolith
A monolith is usually:
- One deployable application.
- One codebase.
- One database (often).
- Clear layers inside, but not split into separate deployable services.
Monoliths are often the best starting point.
Advantages
- Simpler development setup.
- Easier local testing.
- Simpler deployment.
- Easy refactoring across the whole codebase.
- Less operational overhead (no service discovery, message buses, etc.).
Disadvantages
- Can grow into a “big ball of mud” if not structured.
- Teams may step on each other’s toes in the same codebase.
- Harder to scale different parts independently if needed.
- Long build / test times as codebase grows.
When a monolith is a good choice
Use a monolith when:
- You are building an MVP or early product.
- You have a small team.
- Requirements are likely to change a lot.
- You do not yet know the true domain boundaries.
- You do not have strong DevOps capacity.
Example:
- A startup building a new SaaS app. 3 developers. They need to validate the idea quickly. A monolith with a layered structure is perfect.
When to Use a Modular Monolith
What makes a monolith “modular”?
A modular monolith is still:
- One deployable application.
But inside, you enforce strong module boundaries. For example:
usersbillingprojectsnotifications
Each module has its own:
- Domain models.
- Services or use cases.
- Persistence layer adapters.
The rest of the app can only use these through public interfaces.
Advantages
- Many benefits of a monolith (simpler deployment, testing).
- Better separation of concerns.
- Preparation for future microservices if needed.
- Easier to reason about ownership: “Team A owns the billing module.”
Disadvantages
- Requires discipline to keep module boundaries clean.
- Still one deployment artifact. A single bug can impact everything.
- Cannot independently scale modules at the infrastructure level.
When a modular monolith is a good choice
Use a modular monolith when:
- The product has several distinct domains but traffic is not extreme.
- You have multiple developers or teams working on different areas.
- You want to delay microservices until they are really needed.
- You care about keeping a clean architecture over time.
Example:
- A project management SaaS with features like tasks, billing, reporting, teams. A modular monolith lets you organize by domain without microservices complexity.
When to Use Microservices
What microservices really buy you
Microservices turn your system into:
- Many independent deployable services.
- Often each has its own database.
- Communication through HTTP or messaging.
Microservices give you:
- Strong separation of deployment and failure. One service can fail without everything dying.
- Independent scaling for hot services.
- Independent technology choices per service (sometimes).
- Better alignment with large independent teams.
But this comes with cost.
Costs of microservices
- Operational complexity: service discovery, configuration, logging, tracing, monitoring across many services.
- Data consistency becomes harder. You cannot use simple multi table local transactions across services.
- Distributed failures: network issues, timeouts, partial failures.
- Coordination across services for new features.
Rule: Do not choose microservices to fix bad code organization. Fix your design in a monolith first. Microservices amplify both good and bad design.
When microservices are a good choice
Use microservices when:
- You have many teams that need to work independently.
- Different parts of the system have very different scaling or reliability needs.
- Your existing monolith has become painful even after modularization.
- You have strong DevOps / SRE capabilities.
Example:
- A large e commerce platform:
catalog,search,orders,payments,inventory,shipping. Each is owned by a separate team, scaled differently, and has its own uptime and latency needs.
Incremental Migration: From Monolith to Microservices
Why incremental change matters
Most systems do not start as microservices. They evolve.
Common path:
- Simple monolith.
- Modular monolith with clearer boundaries.
- Selected modules extracted into microservices.
This migration should be gradual, not “big bang”.
Example migration path
Imagine your modular monolith has modules:
usersbillingprojectsnotifications
You notice that:
notificationshandles email, SMS, and in app messages.- It is CPU and network heavy.
- It causes long response times for unrelated APIs.
A reasonable plan:
- Keep the core as a modular monolith.
- Create a Notification Service microservice.
- Extract message sending logic into this service.
- Let the monolith call the service through HTTP or publish messages into a queue.
Over time, you might also extract billing into its own service if it needs special compliance or scaling.
Alignment with Teams and Organization
Conway’s Law
Conway’s Law says:
“Any organization that designs a system will produce a design whose structure is a copy of the organization’s communication structure.”
In practice:
- If you have one small team, a monolith is natural.
- If you have many teams, each responsible for a domain, modular or microservice boundaries often follow team boundaries.
Good alignment
- One team per module or service.
- Clear ownership: a team owns code, database tables, APIs.
- Minimal dependencies between teams for most changes.
Bad alignment
- Many teams all edit the same areas of a monolith.
- Changes need coordination across several teams for minor features.
- No clear ownership of modules, everyone touches everything.
When choosing architecture, always ask:
- How many teams will work on this?
- How do they communicate?
- How fast do they need to deploy changes independently?
Non-Functional Requirements and Architecture
Translating requirements into choices
Non functional requirements are things like:
- Maximum response time.
- Uptime targets, such as $99.9\%$.
- Data consistency requirements.
- Compliance or regulatory needs.
- Expected traffic growth.
These influence architecture heavily.
Examples of requirement driven choices
- High uptime and isolation
- A payment subsystem must be very reliable and certified.
- You may isolate it as a separate service with its own database and stricter controls.
- Read heavy analytics
- You might add separate read models or even separate services dedicated to reporting, so that heavy analytics queries do not affect the main transactional database.
- Low latency realtime features
- Chat or trading systems might use WebSockets and specialized services for state and messaging, instead of putting everything into the same REST API monolith.
Whenever you see a strong non functional requirement, ask:
- Does this justify separating this part of the system?
- Or can I still meet this requirement inside a modular monolith with simpler changes?
Technology and Team Skills
Do not ignore what your team can actually do
The best theoretical architecture fails if:
- No one on the team knows how to operate it.
- The tools are too complex.
Consider:
- Programming languages your team knows.
- Cloud and DevOps experience.
- Database knowledge.
- Monitoring and observability skills.
Choosing microservices with Kubernetes, advanced messaging, and complex observability for a 2 person team that just learned Docker is usually a bad idea.
Rule of thumb:
Choose the simplest architecture that your team can operate well, given the business needs.
Decision Framework: Simple Step-by-Step Process
A concrete checklist
When picking an architecture for a new backend project, you can follow a small process.
Step 1: Understand the context
Write down:
- Business goals.
- Expected number of users in the next 6 to 12 months.
- Key non functional requirements (latency, uptime, compliance).
- Team size and skills.
Example:
- 3 devs, launch in 3 months, target 1000 daily active users, no strong compliance.
Step 2: Choose base style
Using the earlier table:
- Small team, early product → Monolith with clear layers.
- Medium team, growing product → Modular monolith.
- Large organization, many teams, strict SLAs → Microservices or hybrid.
Step 3: Identify main domains
List core domains, for example:
users,billing,projects,notifications.
Keep them as modules inside a monolith at first. Name them clearly in your project structure.
Step 4: Evaluate special cases
Ask:
- Is there any domain with special compliance or uptime needs?
- Any domain with very different scaling characteristics?
- Any domain that should be built and deployed independently for business reasons?
These might be candidates for early extraction into separate services.
Step 5: Validate against constraints
Check:
- Can your team reliably run this in production?
- Are you over engineering for the current scale?
- Do you have a migration path if the product grows?
If you are unsure, lean toward simpler.
Step 6: Reevaluate over time
Architecture is not a one time decision. Every few months:
- Look at pain points: build times, coupling, deployment risks, scaling.
- Improve module boundaries.
- Only extract services when clear benefits outweigh the cost.
Example Scenarios and Decisions
Scenario 1: Early stage SaaS
- 2 developers.
- Features: user auth, simple billing, dashboard.
- Expected traffic: low to medium.
- No strict compliance.
Decision:
- Monolith with simple layers: API, services, repository.
- Maybe a bit of modular structure by feature folders.
- Focus on shipping quickly, tests, and clean code.
Scenario 2: Growing product with 3 squads
- 12 developers in 3 teams.
- Features: subscription billing, projects, reporting, notifications.
- Traffic is growing.
Decision:
- Modular monolith.
- Clear domains:
billing,projects,reporting,notifications. - Each team owns one or two modules.
- Strong internal APIs between modules, no direct database cross access.
- Prepare for possible future extraction of heavy or isolated modules.
Scenario 3: Large marketplace
- 100+ developers.
- Many subdomains: product catalog, search, payments, orders, delivery.
- High traffic, global users, strict uptime and compliance.
Decision:
- Microservices or service oriented architecture.
- Each major domain is a separate service or set of services.
- Strong DevOps, observability, and platform engineering support.
- Contract first API design between services.
- Use asynchronous messaging for decoupling where appropriate.
How to Avoid Common Architecture Mistakes
Overengineering
- Using microservices for a weekend project.
- Introducing message queues, complex event buses, and multiple databases when you only have a few endpoints.
Avoid by:
- Starting as simple as possible.
- Adding complexity only when a clear problem appears.
Underengineering
- One huge file for everything.
- No separation between API, business logic, and data access.
- Directly coupling external APIs deep inside core logic.
Avoid by:
- At least using a layered structure inside even the smallest monolith.
- Introducing basic patterns like service and repository layers to keep boundaries clear.
Ignoring evolution
- Designing as if the first version will never change.
- Not planning any path to modularization or extraction.
Avoid by:
- Structuring your monolith so that domains are clear.
- Keeping dependencies one directional, from outer layers to inner ones.
Putting It All Together
Choosing an architecture is about matching:
- The problem domain.
- The non functional requirements.
- The team and organization.
- The expected evolution of the product.
You have tools:
- Monolith for simplicity and speed.
- Modular monolith for growing products and multiple teams.
- Microservices for large scale, many teams, and strong isolation.
For an absolute beginner backend developer, the most important habits are:
- Start with a simple monolith and learn to apply clean layering and separation of concerns.
- Practice organizing code by domain inside a monolith, as if each domain could one day become its own service.
- Learn to ask: “What real problem am I solving with this architectural choice?”
If you consistently choose the simplest architecture that satisfies your current needs, and you keep refactoring as your system grows, your architecture decisions will age well.
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!