14.1. Users and Permissions
Table of Contents
Understanding Users and Permissions
In authorization, everything starts with who is acting and what they are allowed to do. This chapter focuses on users and permissions as the raw building blocks of authorization. Later chapters will cover more elaborate schemes like roles and advanced access control, so here we will stay close to the basics and focus on what is unique to users and permissions themselves.
Users as Subjects in Your System
In authorization, a user is a subject: someone or something that tries to perform an action on a resource.
Common subjects:
- Human users
- Service accounts (for other services or background jobs)
- API clients (e.g. a third party integration)
In code and in the database, users are usually represented by a user record and a user identifier.
Example user table:
| Column | Type | Example | Purpose |
|---|---|---|---|
| id | UUID / int | 42 or 9b3d-... | Primary key, internal identifier |
| string | alice@example.com | Login / contact | |
| password_hash | string | $2b$12$... | Authentication, not authorization |
| is_active | boolean | true | Can user log in? |
| created_at | timestamp | 2026-08-01 10:30 | Audit / info |
Authentication tells you “This is user #42”. Authorization then needs to decide “What is user #42 allowed to do?”.
What Are Permissions?
A permission describes an allowed action on a type of resource, optionally within some scope.
Typical pieces of a permission:
- Action:
read,create,update,delete,list,approve, etc. - Resource type:
user,order,product,invoice,comment, etc. - Scope: which instances, which organization, which tenant, which project, etc.
You can think of a permission as a simple sentence:
“User mayACTIONRESOURCEinSCOPE.”
Examples:
read:articleupdate:orderdelete:commentapprove:paymentread:report:department:finance
To make this manageable in code and database, it is common to represent permissions using machine friendly strings like:
user.readuser.updateproduct.createinvoice.refund
Or with structured data:
{
"action": "read",
"resource": "user",
"scope": "self"
}Important rule: A permission is always about an action on a resource. If your permission name does not clearly imply an action and a resource, it will quickly become confusing.
Basic Permission Models
Simple Boolean Flags
The simplest form is a boolean flag on the user:
| Column | Type | Meaning |
|---|---|---|
| is_admin | bool | Can perform admin actions |
| can_post | bool | Can create posts |
| can_comment | bool | Can add comments |
Example:
if not current_user.can_post:
raise HTTPException(status_code=403, detail="Posting not allowed")This works for very small applications, but it does not scale:
- Hard to add new permissions without adding new columns
- Combinations become messy
- Not flexible per resource instance
Use it only for very small features or extremely stable rules, like is_superuser.
List of Permission Strings
A flexible approach is to give each user a list of permission strings.
Example:
{
"id": 42,
"email": "alice@example.com",
"permissions": [
"post.create",
"post.update.self",
"comment.create",
"comment.delete.self"
]
}In code:
def has_permission(user, permission: str) -> bool:
return permission in user.permissionsChecking:
if not has_permission(current_user, "post.create"):
raise HTTPException(status_code=403, detail="Not allowed to create posts")This model is:
- Easy to understand
- Easy to store (e.g. separate table or JSON field)
- Easy to check in code
You will later see how to combine this with roles, but the underlying idea of a list of permission strings is the same.
Permissions and Resources
Permissions become meaningful when tied to resources. Two big questions:
- Does a user have permission for this type of resource?
- Does a user have permission for this specific instance of the resource?
Type-Level Permissions
Type-level permissions care only about the kind of resource, not which instance.
Examples:
product.readuser.listreport.generate
Check:
def can_read_products(user):
return "product.read" in user.permissionsInstance-Level Permissions (Ownership)
Often, you want rules like:
- User can edit only their own profile
- User can update only their own posts
- User can view only orders from their organization
In that case, you combine a generic permission with a resource ownership check.
Example database tables:
users
| id | |
|---|---|
| 1 | alice@example.com |
| 2 | bob@example.com |
posts
| id | title | user_id |
|---|---|---|
| 10 | "Hello" | 1 |
| 11 | "Bye" | 2 |
A common rule:
- User needs permission
post.update.self - And must own the post (
post.user_id == current_user.id)
Check in code:
def can_update_post(user, post):
if "post.update.any" in user.permissions:
return True # e.g. moderator
if "post.update.self" in user.permissions and post.user_id == user.id:
return True
return FalseThis simple pattern combines permissions with ownership, a very common requirement in real applications.
Designing Permissions
Designing permissions is a bit like designing a public API. If you are not careful, it can become hard to maintain.
Define Actions Clearly
Pick a small, consistent set of actions and reuse them across resources.
Common actions:
createreadorviewupdateoreditdeletelistexportapprove/rejectassign
Example pattern:
user.readuser.updateuser.deleteorder.readorder.updateorder.refund
Try to avoid inventing new verbs for the same concept. For example, do not mix view, read, and see for the same action.
Design rule: Use a consistent naming convention for permissions, for example:
<resource>.<action>[.<scope>]
Example: post.update.self, order.read.any.
Keep Permissions Close to Use Cases
Do not create permissions for every tiny method or field. Instead, think in use cases.
Example, comment system:
- View a post and its comments:
post.read - Add a comment:
comment.create - Edit own comment:
comment.update.self - Delete comments for moderation:
comment.delete.any
This is enough. You probably do not need comment.update.text_only or comment.update.author_only unless your product really needs it.
Example Permission Matrix
A matrix can help you think about which permissions you need.
Example: Blogging system
| Resource | Action | Permission string | Notes |
|---|---|---|---|
| post | create | post.create | Create a new post |
| post | read | post.read | Read any published post |
| post | update self | post.update.self | Edit own posts |
| post | update any | post.update.any | Moderator or admin |
| post | delete self | post.delete.self | Delete own posts |
| post | delete any | post.delete.any | Moderator or admin |
| comment | create | comment.create | Add comments |
| comment | delete self | comment.delete.self | Delete own comments |
| comment | delete any | comment.delete.any | Moderator |
Once this is defined, your code becomes more structured and readable.
Storing Permissions
You will usually store permissions in the database rather than hardcoding everything.
Separate Permission Table
A normalized design:
permissions
| id | name | description |
|---|---|---|
| 1 | post.create | Create new posts |
| 2 | post.update.self | Update own posts |
| 3 | post.update.any | Update any posts |
user_permissions
| user_id | permission_id |
|---|---|
| 1 | 1 |
| 1 | 2 |
| 2 | 1 |
| 2 | 3 |
This gives you:
- A central place to see all permissions
- Ability to add or remove permissions without changing database schema
- Ability to attach permissions directly to users
Example query to get a user’s permissions:
SELECT p.name
FROM permissions p
JOIN user_permissions up ON p.id = up.permission_id
WHERE up.user_id = 1;You can cache the resulting list in memory or in a token for faster checks.
Embedding Permissions in Tokens
In many backend APIs, you include permissions inside a JWT access token after login. For example:
{
"sub": "42",
"email": "alice@example.com",
"permissions": [
"post.create",
"post.update.self",
"comment.create"
],
"exp": 1724760000
}Then each request does not need to hit the database to check permissions, it can read them from the token. Just remember that changes to permissions might not take effect until old tokens expire.
Checking Permissions in Code
Centralize Permission Checks
You should avoid sprinkling string checks all over the code without structure.
Bad:
if "post.update.self" in current_user.permissions or "post.update.any" in current_user.permissions:
# editing logic
else:
raise HTTPException(403)Better, define helper functions:
def has_permission(user, permission: str) -> bool:
return permission in user.permissions
def require_permission(user, permission: str):
if not has_permission(user, permission):
raise HTTPException(status_code=403, detail="Forbidden")Use it:
@app.post("/posts")
def create_post(post_in: PostCreate, user: User = Depends(get_current_user)):
require_permission(user, "post.create")
# create postCombine Permission and Ownership Checks
Example with FastAPI style:
from fastapi import Depends, HTTPException
def can_edit_post(user, post) -> bool:
if "post.update.any" in user.permissions:
return True
if "post.update.self" in user.permissions and post.user_id == user.id:
return True
return False
@app.put("/posts/{post_id}")
def update_post(
post_id: int,
post_in: PostUpdate,
user: User = Depends(get_current_user),
):
post = get_post_by_id(post_id)
if post is None:
raise HTTPException(status_code=404, detail="Post not found")
if not can_edit_post(user, post):
raise HTTPException(status_code=403, detail="Not allowed to edit this post")
# perform updateThis keeps your authorization logic clear and testable.
Service Accounts and Non Human Users
Not all users are people. A common pattern is service accounts or API clients.
Examples:
- Background worker that sends emails
- Script that runs reports nightly
- Third party app that uses your API
These often:
- Do not have a password but use tokens or keys
- Have very specific permissions
Example service account:
{
"id": 1001,
"name": "report-generator",
"type": "service",
"permissions": [
"report.generate",
"report.read"
]
}In code, you can treat them like any other user, but possibly with an extra flag:
if current_user.type == "service" and "user.update" in current_user.permissions:
# maybe restrict some actions furtherKeep the same permission concepts so your authorization logic is consistent.
Example: Designing Users and Permissions for a Simple API
Imagine you are building a Task Management API with:
- Users
- Tasks owned by users
- Admins who can see and manage all tasks
Resources
usertask
Actions
create,read,update,delete,list
Permissions
| Resource | Action | Permission | Who gets it |
|---|---|---|---|
| task | create | task.create | All regular users, admins |
| task | read self | task.read.self | All regular users |
| task | read any | task.read.any | Admins |
| task | update self | task.update.self | All regular users |
| task | update any | task.update.any | Admins |
| task | delete self | task.delete.self | All regular users |
| task | delete any | task.delete.any | Admins |
| user | list | user.list | Admins only |
| user | read self | user.read.self | Every user |
| user | update self | user.update.self | Every user |
Example Checks
List user’s own tasks:
@app.get("/tasks")
def list_my_tasks(user: User = Depends(get_current_user)):
require_permission(user, "task.read.self")
return get_tasks_by_user_id(user.id)Admin listing all users:
@app.get("/admin/users")
def list_users(user: User = Depends(get_current_user)):
require_permission(user, "user.list")
return get_all_users()Updating a task:
@app.put("/tasks/{task_id}")
def update_task(
task_id: int,
task_in: TaskUpdate,
user: User = Depends(get_current_user),
):
task = get_task_by_id(task_id)
if not task:
raise HTTPException(status_code=404, detail="Task not found")
if "task.update.any" in user.permissions:
pass # ok, admin
elif "task.update.self" in user.permissions and task.owner_id == user.id:
pass # ok, owner
else:
raise HTTPException(status_code=403, detail="Not allowed to update this task")
# perform updateThis small example shows how user records and permission strings combine to form a clear and testable authorization layer.
Good Practices for Users and Permissions
- Least privilege:
Give users only the permissions they really need. - Centralized logic:
Keep permission names and checks in a few places, not scattered everywhere. - Consistent naming:
Stick to a naming pattern likeresource.action.scope. - Test your rules:
Write tests for permission logic, especially when you add or change permissions. - Plan for growth:
Start simple, but design so you can later introduce roles or more advanced models without changing everything.
Key statement: Authorization is easiest to maintain when you treat permissions as a clear, stable contract between your business rules and your code.
Later chapters will build on this foundation to introduce role based access control and more advanced authorization models, but the core concepts of users and permissions remain the same.
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!