14.3. Permission-Based Access Control
Table of Contents
Understanding Permission-Based Access Control
Role based access control (RBAC) gives users roles like admin or user. Permission based access control (PBAC) goes one level deeper and works with fine grained actions such as read:users or delete:orders. In backend development, you often combine both ideas, but here we focus on the permission side itself.
This chapter assumes you already understand users and permissions in general, and basic role based access control. We will focus on what is specific to permission based access control and how to implement it in a backend API.
What Is Permission-Based Access Control?
In permission based access control, the central concept is the permission, not the role.
A permission describes a specific allowed action on a specific type of resource, for example:
users:readusers:writeorders:readorders:cancelproducts:createproducts:delete
You then assign permissions to users, roles, or both. When the user calls your API, your backend checks whether the user has the required permission for that operation.
Key idea: In PBAC, access decisions are based on individual permissions, not only on high level roles.
Typical features of PBAC:
- Very fine grained control over what each user can do
- Easier to add or remove a single capability without changing the whole role
- Good fit for complex business rules
PBAC is often implemented on top of RBAC:
- Roles are collections of permissions
- Users are assigned roles
- Permissions are checked at runtime
You can also assign permissions directly to users for exceptions.
Permission Models and Naming
Designing Permissions
You need a consistent way to name permissions. A simple and popular pattern is:
$resource:$action
Examples:
| Resource | Action | Permission string |
|---|---|---|
users | read | users:read |
users | update | users:update |
orders | create | orders:create |
orders | cancel | orders:cancel |
products | delete | products:delete |
For more complex systems, you might add a third piece:
$resource:$action:$scope
Examples:
| Resource | Action | Scope | Permission |
|---|---|---|---|
orders | read | own | orders:read:own |
orders | read | all | orders:read:all |
users | read | profile | users:read:profile |
Rule: Choose a simple, consistent naming scheme for permissions and use it everywhere in your code and database.
CRUD-based Permissions
For APIs built around standard CRUD operations, you often define permissions like:
resource:createresource:readresource:updateresource:delete
For example:
tasks:create,tasks:read,tasks:update,tasks:deletecomments:create,comments:delete
You can also define special actions that are not CRUD:
orders:refundorders:shipreports:export
Static vs Dynamic Permissions
There are two common approaches:
- Static permission list in code
- You define a central list like:
PERMISSIONS = [
"users:read",
"users:update",
"orders:read",
"orders:create",
"orders:cancel",
]- Good for small to medium systems
- Easier to reason about and test
- Dynamic permissions in database
- Permissions are rows in a
permissionstable - Admins can create new permissions from an admin UI
- More flexible, but also more complex
For beginners, keeping a static list in code and linking it to database rows is often a good compromise.
Storing Permissions in the Database
Although exact schema design belongs in database chapters, it is useful to see how a typical PBAC database model looks at a high level.
Common Schema
A common schema for permissions is:
| Table | Purpose |
|---|---|
users | Application users |
roles | Named roles (admin, editor, viewer) |
permissions | Permission definitions (orders:read) |
user_roles | Many to many between users and roles |
role_permissions | Many to many between roles and permissions |
user_permissions | Optional, direct permissions per user |
You do not need all of these from day one, but the pattern is useful.
A simplified version:
users
id
email
...
roles
id
name -- e.g. "admin"
permissions
id
name -- e.g. "orders:read"
user_roles
user_id
role_id
role_permissions
role_id
permission_id
user_permissions
user_id
permission_idWith this, you can answer:
- Which permissions does user 42 have?
- Which users have permission
orders:cancel? - Which permissions belong to the
managerrole?
Important: Store permissions normalized, do not keep a comma separated string like "orders:read,orders:cancel" in a single column. Use join tables instead.
Checking Permissions in Your Backend
The heart of PBAC is the permission check that happens inside your backend application.
Basic Permission Check Flow
When handling a request, the backend usually:
- Authenticates the user (for example via a session or JWT)
- Loads all permissions of the user (from DB or from a token)
- Checks if the user has the required permission
- If not, returns
403 Forbidden
In plain pseudocode:
def has_permission(user, permission: str) -> bool:
return permission in user.permissionsThen in your API endpoint:
def cancel_order(order_id, user):
if not has_permission(user, "orders:cancel"):
raise ForbiddenError("Missing permission: orders:cancel")
# continue with cancel logicCombining RBAC and PBAC
If you have roles, and permissions attached to roles, you often do something like:
- Load user roles
- Load permissions for all these roles
- Add direct user permissions if you support them
- Combine into a set
Example flow:
def load_user_permissions(user_id: int) -> set[str]:
role_permissions = query_role_permissions_for_user(user_id)
direct_permissions = query_direct_permissions_for_user(user_id)
return set(role_permissions) | set(direct_permissions)Then:
def has_permission(user_id: int, permission: str) -> bool:
permissions = load_user_permissions(user_id)
return permission in permissionsYou usually add caching to avoid hitting the database for every request, but the concept is the same.
Permission Check Location
You have several places where you can enforce permissions:
| Location | Example | Pros | Cons |
|---|---|---|---|
| In route / handler | Check in each endpoint | Very explicit | Repeated code |
| As decorator | @require_permission("x:y") | Reusable, clean | Needs some framework knowledge |
| As middleware | Check certain paths | Central place, less duplication | Harder to handle very specific conditions |
| In service layer | Inside business logic functions | Keeps HTTP layer clean | Must not forget to call it everywhere |
Most backends use decorators or framework specific mechanisms to keep APIs clean.
Permissions vs Roles in Practice
Permission based access control is often introduced because RBAC alone becomes too coarse.
Where RBAC Alone Fails
Imagine you only have these roles:
adminmanageruser
Some real world needs:
- A support person can read all orders, but cannot refund them
- A finance person can refund orders, but cannot delete users
- A marketing person can export reports, but not see raw user data
If you try to model this with only roles, you might end up creating too many roles:
support_read_orders_no_refundsupport_read_orders_and_refundsupport_only_read_own_orders
This becomes unmanageable.
With PBAC, you do:
orders:read:allorders:refundusers:deletereports:export
Then give each user exactly the set of permissions they need, directly or through roles.
Combining RBAC and PBAC
A typical pattern is:
- Use roles for grouping permissions into job profiles, for example
support_agent,finance_analyst - Use permissions as the unit of access control, like
orders:refund
For example:
support_agentrole:orders:read:allusers:read:profilefinance_analystrole:orders:read:allorders:refund
Users get one or more roles, and possibly extra direct permissions such as reports:export.
Designing Permission Boundaries
Permission based access control is only as good as the way you define boundaries around actions.
Coarse vs Fine Grained Permissions
If you define:
orders:full_access
Then every user with this permission can do everything with orders, which is not very safe.
If you define:
orders:readorders:updateorders:cancelorders:refundorders:delete
You have more flexibility, but also more entities to manage.
A good practice is to:
- Start with CRUD level permissions
- Split permissions only where real business rules need it
For example:
orders:read(view)orders:update(edit data)orders:cancel(customer initiated cancel)orders:refund(money movement, more sensitive)
Rule: Split permissions when actions have different risk levels or different business owners.
Ownership vs Global Permissions
PBAC focuses on what the user can do, but often you also need to know to which resources they can do it.
For example, an user might be allowed to read only their own orders, not all orders. You can model this in two ways:
- Permissions encode scope:
orders:read:ownorders:read:all
The code then checks both permission and ownership.
- Permissions encode only the action, and separate logic enforces ownership.
- Permission:
orders:read - Business rule: if the user is not an admin, only show orders where
order.user_id == current_user.id
The second method is more common, but for very complex systems the first method can be helpful.
Implementing Permission Checks in a Web API
Here we focus on how permission based access looks from an API and backend perspective.
Example Endpoint Requirements
Imagine a Task Management API with permissions:
tasks:createtasks:readtasks:updatetasks:delete
Possible policy:
| Endpoint | Required permission |
|---|---|
POST /tasks | tasks:create |
GET /tasks | tasks:read |
GET /tasks/{task_id} | tasks:read |
PUT /tasks/{task_id} | tasks:update |
DELETE /tasks/{task_id} | tasks:delete |
At the code level, you might define a simple decorator:
def require_permission(permission: str):
def decorator(handler):
def wrapper(request, *args, **kwargs):
user = request.user
if permission not in user.permissions:
raise ForbiddenError(f"Missing permission: {permission}")
return handler(request, *args, **kwargs)
return wrapper
return decoratorThen use it:
@require_permission("tasks:create")
def create_task(request):
...
@require_permission("tasks:delete")
def delete_task(request, task_id):
...Permissions in JWT Tokens
In token based authentication, you can include permissions in the token payload so you do not need a database query on every request.
Example JWT payload:
{
"sub": "123",
"email": "alice@example.com",
"permissions": [
"tasks:create",
"tasks:read",
"tasks:update"
],
"exp": 1735690000
}At request time:
- Verify token
- Extract
permissionsclaim - Check if required permission is in this list
Tradeoff:
- Faster checks, no DB hit
- Permissions are frozen until the token expires
- If you revoke a permission, existing tokens still allow it until expiration
Often you combine:
- Short lived access tokens with embedded permissions
- When permissions change, you invalidate refresh tokens or maintain a token blacklist
Common Patterns and Examples
Permission Hierarchies
Sometimes you want one permission to imply others. For example:
orders:adminmeans:orders:readorders:createorders:updateorders:delete
You can implement permission hierarchies in code:
PERMISSION_TREE = {
"orders:admin": [
"orders:read",
"orders:create",
"orders:update",
"orders:delete",
]
}Then when you load user permissions, expand them:
def expand_permissions(perms: set[str]) -> set[str]:
expanded = set(perms)
for perm in list(perms):
children = PERMISSION_TREE.get(perm, [])
expanded.update(children)
return expanded
So if a user has orders:admin, checks for orders:read or orders:update will pass.
Feature Flags vs Permissions
Sometimes you see feature flags used in similar ways to permissions. Key differences:
| Aspect | Permissions | Feature Flags |
|---|---|---|
| Target | Security, access control | Gradual rollout, experiments |
| Who controls | Security / product owners | Product managers, developers |
| Lifetime | Long term, part of policy | Often temporary |
You might have both:
- Permission:
reports:export - Feature flag:
enable_new_report_export_ui
The permission is checked on the backend. The feature flag might be used in frontend to show or hide new UI elements.
Example: Combining User Attributes and Permissions
PBAC does not replace business rules. For example, a business rule could be:
- Only allow refunds for orders that are less than 30 days old
- Even if the user has
orders:refund
Your code could look like:
def refund_order(order_id: int, user):
if "orders:refund" not in user.permissions:
raise ForbiddenError("Missing permission orders:refund")
order = get_order(order_id)
if order.age_in_days > 30:
raise BusinessRuleError("Order too old to refund")
# process refundPermissions are about who can try a certain action. Business rules are about when the action is allowed.
Managing Permissions Over Time
In real systems, permissions evolve. You need ways to maintain and migrate them.
Changing or Removing Permissions
If you rename or remove permissions, you must:
- Update references in code
- Migrate database records
- Regenerate or expire tokens if they include old permission names
Example migration:
- Old permission:
orders:refund - New permissions:
orders:refund:partialorders:refund:full
Migration path:
- Add new permissions to
permissionstable - For each user that had
orders:refund, decide which of the new ones they need - Update role and user permission mappings
- Remove old permission from code and DB
Auditing and Logging
Permission systems are often used in sensitive contexts. You should log:
- When permissions are granted or revoked
- Who changed them
- When someone attempts an action without the required permission
Example log entries:
2026-01-01T10:00Z admin@company.com granted 'orders:refund' to user 'bob@example.com'2026-01-02T08:12Z user 'bob@example.com' denied 'users:delete' on /users/42
These logs can be crucial for debugging and for security investigations.
Summary
Permission based access control focuses on specific, named permissions like orders:read or tasks:delete. It gives you fine grained control over what users can do and is often built on top of roles that group those permissions.
Key points to remember:
- Use a consistent naming scheme for permissions, such as
resource:actionorresource:action:scope. - Store permissions in a normalized way, linking users, roles, and permissions via join tables.
- Always check permissions in your backend, usually via decorators, middleware, or service layer checks.
- Permissions handle who is allowed to attempt an action. Business rules still validate when the action is valid.
- Plan for evolution of permissions, including migrations and auditing changes.
With these patterns, you can design backends that are both flexible and secure, and that adapt as your application's requirements grow more complex.
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!