14.5. Admin Permissions
Table of Contents
Why Admin Permissions Exist
In most real applications not every authenticated user should be allowed to do everything. Some actions are dangerous or sensitive, for example:
- Deleting users
- Refunding payments
- Changing roles and permissions
- Viewing all customer data
- Managing system configuration
These actions are usually reserved for administrators.
Admin permissions are a specific case of authorization. You decide which users are "admins" and you enforce that only they can call certain endpoints or perform certain operations.
Typical user groups:
| Role | Typical abilities |
|---|---|
| Guest | Read public data only |
| User | Manage own data, create content |
| Moderator | Moderate user content, ban users, but not manage the system |
| Admin | Manage users, permissions, settings, critical operations |
| Super admin | Full system control, including other admins |
Admin permissions are usually modeled on top of your existing role or permission system, not as a separate concept.
Key rule: Never rely only on the frontend to hide admin features. Every admin-only capability must also be protected on the backend.
If the JavaScript can see it, a user can usually trigger it. The backend must always check permissions independently.
Representing Admin Permissions
You need a way to store the information that a user is an admin and to use it in authorization checks.
Common ways to store admin status
1. Role field on the user
The most common solution is to store a "role" field on the user.
Example user table:
| Column | Type | Example value |
|---|---|---|
| id | int | 42 |
| text | alice@example.com | |
| password | hash | $2b$12$... |
| role | text | "user" or "admin" |
| is_active | boolean | true |
You can define a small set of allowed values: "user", "admin", "super_admin".
In code, this becomes very simple:
class Role(str, Enum):
USER = "user"
ADMIN = "admin"
SUPER_ADMIN = "super_admin"
Then each user has a role column that uses one of these.
2. Explicit boolean flag
Instead of a text role, you can have fields like:
is_admin(boolean)is_staff(boolean)
Example:
| id | is_admin | is_staff | |
|---|---|---|---|
| 1 | admin@example.com | true | true |
| 2 | staff@example.com | false | true |
| 3 | user@example.com | false | false |
This is easy if your app is small. For complex systems with many roles, this becomes hard to maintain.
3. Role table and many-to-many relation
For more flexibility, you can have:
userstablerolestable (withname="admin","user","moderator")user_rolestable that connects users to roles
Then you can give multiple roles to one user. Admin is just one of the roles.
Example rows:
roles:
| id | name |
|---|---|
| 1 | user |
| 2 | admin |
| 3 | editor |
user_roles:
| user_id | role_id |
|---|
| 1 | 2 | user 1 is admin
| 1 | 1 | and user
| 2 | 1 | user 2 is only user
This fits naturally into a permission system where admin is a role with special rights.
4. Permission-based admin
In a permission-based system, admin can be:
- a role that has all permissions, or
- a shortcut flag
is_super_adminthat bypasses other checks.
For example:
| Permission | Admin has it? |
|---|---|
user.create | yes |
user.delete | yes |
product.update | yes |
system.settings.update | yes |
You can define that:
- Admin role automatically has all permissions.
- Or when checking permissions, if
user.is_administrue, you allow all operations.
Important: Avoid mixing too many patterns. Pick a primary model, for example a role field or a role table, and build on that. Adding extra flags everywhere often leads to inconsistent behavior.
Protecting Admin Endpoints
Admin permissions matter most when you protect backend routes that can change a lot of data or configuration.
Example admin-only endpoints
Typical admin endpoints in a REST API:
POST /admin/userscreate new usersGET /admin/userslist all usersDELETE /admin/users/{user_id}delete any userPOST /admin/productscreate productsGET /admin/statsview system statisticsPATCH /admin/settingschange application configuration
All these need additional protection beyond "user is logged in".
Basic admin check pattern
Conceptually, admin protection is:
- Authenticate the user.
- Load the user record.
- Check if the user is admin.
- If not, return
403 Forbidden. - If yes, continue the handler.
Example in pseudocode:
function require_admin(request):
user = authenticate(request)
if user is None:
return 401 Unauthorized
if not user.is_admin:
return 403 Forbidden
return user
Then each admin endpoint uses require_admin:
function delete_user_endpoint(request, user_id):
admin = require_admin(request)
if is_error(admin):
return admin # 401 or 403
delete_user_by_id(user_id)
return 204 No ContentFastAPI-style example
Assume you already have authentication and a get_current_user dependency:
from fastapi import Depends, HTTPException, status
def require_admin(current_user = Depends(get_current_user)):
if current_user.role != "admin":
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Admin privileges required",
)
return current_userThen an admin route:
from fastapi import APIRouter
router = APIRouter(prefix="/admin", tags=["admin"])
@router.get("/users")
def list_all_users(admin = Depends(require_admin)):
# admin is the current user with admin role
return get_all_users()Points to notice:
- The route does not trust the frontend.
- The route does not check
X-Admin: trueheaders or anything the client sets. - It only trusts the authenticated user record from the database or token.
Never trust client claims like "role": "admin" sent directly from the browser. The backend must validate admin status from a secure source, such as a signed token or database lookup.
Using JWTs with admin roles
If you use JWTs, you usually store the user's role inside the token payload:
{
"sub": "42",
"email": "admin@example.com",
"role": "admin",
"exp": 1729614941
}The important part:
- The JWT is signed by your backend.
- The client cannot modify the payload without breaking the signature.
- When the backend verifies the token, it can safely read
"role": "admin".
Then your get_current_user (or similar) reads the role from the JWT, and require_admin checks that the role is "admin".
If your system lets users change role in the database while tokens are still valid, you might want to:
- Either keep JWT lifetimes short.
- Or load the user from the database and trust the database role, not the token role.
Admin Areas vs Regular Areas
It is very common to separate admin functionality into an "Admin Area" both in the API and in the frontend.
URL separation
You can group admin endpoints under a specific prefix:
- Regular API:
/api/v1/... - Admin API:
/api/v1/admin/...
Examples:
| Regular endpoint | Admin endpoint |
|---|---|
GET /api/v1/products | POST /api/v1/admin/products |
GET /api/v1/orders/me | GET /api/v1/admin/orders |
PATCH /api/v1/users/me | PATCH /api/v1/admin/users/{user_id} |
DELETE /api/v1/orders/{order_id} | POST /api/v1/admin/orders/{id}/refund |
This makes your API more understandable:
- Everything under
/adminis clearly sensitive. - You can apply special middleware or rate limiting to
/admin/*. - You can log admin actions separately.
Separate admin frontend
Often you have:
- Public frontend:
https://example.com/ - Admin dashboard:
https://admin.example.com/orhttps://example.com/admin/
The admin frontend might be a separate Single Page Application that calls only admin API routes.
Even if you use separate domains or paths for the UI, you must still protect the admin API routes with proper authorization on the backend.
Common Admin Pitfalls
Admin permissions are powerful and often poorly implemented. Here are typical mistakes and how to avoid them.
Relying on the frontend
Bad pattern:
- Hide the "Delete user" button in the UI for non-admins.
- Do not enforce any admin check in the backend.
Problem:
- A non-admin user can still send an HTTP
DELETE /admin/users/123request manually with curl, Postman, or the browser console. - Because the backend does not check admin role, the request succeeds.
Always implement permission checks on the server side.
Relying on a client-provided header or field
Bad pattern:
DELETE /admin/users/123
X-User-Role: admin
If your backend uses the X-User-Role header as the source of truth, then any client can become an admin by sending that header.
Correct approach:
- Ignore any role fields coming from the client.
- Only use roles that come from a trusted source:
- The user record in your database, or
- The claims in a verified JWT token.
Missing check inside business logic
Sometimes you protect the endpoint but forget to protect the internal service function.
Example:
def delete_user(user_id: int):
# Dangerous operation
db.delete(User).where(User.id == user_id)
If you call delete_user from an admin endpoint, you might think you are safe. But later someone might reuse delete_user from a non-admin endpoint by mistake.
Safer pattern:
def delete_user_as_admin(current_user, user_id: int):
if not current_user.is_admin:
raise PermissionError("Admin required")
db.delete(User).where(User.id == user_id)
Or require admin in the function signature:
def delete_user_as_admin(admin_user: AdminUser, user_id: int):
# Type or class ensures this is admin
...In small projects you can keep checks in the route handlers. In larger systems it is often better to put permission checks inside the service layer too.
Super admin and self-lockout
If you only have one admin user or one "super admin" and you remove its admin role, you can lock yourself out of the system.
Common mistake:
- Admin A removes its own admin role by accident.
- There is no other admin.
- No one can promote any user to admin again.
To avoid this:
- Have at least two accounts with super admin rights.
- Or disallow:
- Removing the last admin role.
- An admin from removing its own admin role without confirmation.
Example logic:
if current_user.id == target_user.id and current_user.role == "super_admin":
if count_super_admins() == 1:
disallow("Cannot remove last super admin")Insecure "temporary" admin logic
Developers sometimes add temporary shortcuts during development, for example:
def require_admin(user):
# TODO: remove this in production
if user.email.endswith("@mycompany.com"):
return user
if user.role != "admin":
raise Forbidden
If you forget to remove this before production, anyone who can register with a @mycompany.com email becomes admin.
Avoid these shortcuts entirely, or guard them with strict feature flags or environment variables that are not enabled in production.
Auditing and Logging Admin Actions
Admin actions are high impact. You usually want to know:
- Which admin did what
- When they did it
- From where (IP, device)
This is important for:
- Debugging mistakes
- Detecting malicious admin behavior
- Compliance and regulations (for example GDPR, financial systems)
What to log
You can log at least:
admin_user_idaction(for example"DELETE_USER")target(for example"user_id=123")timestampip_address
Simple example:
2026-08-27T12:00:34Z admin_id=1 action=DELETE_USER target_user_id=123 ip=192.168.1.10
2026-08-27T12:05:10Z admin_id=1 action=UPDATE_SETTINGS key=max_login_attempts value=10In code, you might have a helper:
def log_admin_action(admin_user, action: str, target: str = ""):
logger.info(
"admin_action",
extra={
"admin_id": admin_user.id,
"action": action,
"target": target,
},
)Then in an endpoint:
@router.delete("/users/{user_id}")
def delete_user(user_id: int, admin = Depends(require_admin)):
delete_user_by_id(user_id)
log_admin_action(admin, action="DELETE_USER", target=f"user_id={user_id}")
return Response(status_code=204)Rule: Any operation that changes many records or system configuration should be logged with the admin identity and action details.
Designing Admin Permissions Safely
Admin permissions are about scope and limits. Full "god mode" admin might not always be necessary.
Levels of admin
You can define several admin types:
| Admin type | Description |
|---|---|
| Content admin | Manage posts, comments, media |
| Support admin | View user accounts, reset passwords, but not delete users |
| Finance admin | View and manage payments and invoices |
| System admin | Manage configuration, roles, and other admins |
This is often easier to manage with roles and permissions, not just a single boolean is_admin.
Examples of permission strings:
user.readuser.writeuser.deletesettings.updatepayment.refundrole.assign
Then you can give:
- Support admin:
user.read,user.write,password.reset - System admin:
settings.update,role.assign, everything else
Admin is then just a role that has many permissions.
Scoping admin actions
Sometimes admin should have power but still not unlimited.
Examples:
- Support admin can see last 4 digits of a credit card only, not the full number.
- Content admin can delete posts but not delete user accounts.
- Admin can see full logs but not raw passwords (you should not store them anyway).
Design with the principle of least privilege:
- Give the minimum rights needed to do the job.
- Split powerful actions into several smaller permissions.
Admin actions that need confirmation
Some operations are so dangerous that even an admin should have an extra confirmation or step, for example:
- Deleting the entire database
- Disabling login for all users
- Changing encryption keys
Possible safeguards:
- Second admin confirmation
- Extra password prompt for the admin
- Time lock, for example request now and execute after some delay
- Email notification to all super admins when such actions happen
These workflows may be complex but they greatly reduce the risk of accidental catastrophe.
Simple Example: Admin Protection in a Task API
To connect concepts with a concrete example, imagine a simple task management API.
Data model
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
email = Column(String, unique=True, nullable=False)
password_hash = Column(String, nullable=False)
role = Column(String, nullable=False, default="user") # "user" or "admin"
class Task(Base):
__tablename__ = "tasks"
id = Column(Integer, primary_key=True)
owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
title = Column(String, nullable=False)
description = Column(Text)Permissions
- Regular users:
- Can create tasks with
owner_id = their own id - Can read and edit only their own tasks
- Admin users:
- Can read and edit any task
- Can list all tasks
Endpoints
GET /tasks:- Regular user: see only own tasks.
- Admin: see all tasks.
DELETE /tasks/{task_id}:- Regular user: delete only own tasks.
- Admin: delete any task.
GET /admin/users:- Admin only: list all users.
Implementation idea
def get_tasks(current_user):
if current_user.role == "admin":
return db.query(Task).all()
else:
return db.query(Task).filter(Task.owner_id == current_user.id).all()And admin-only endpoint:
def require_admin(current_user):
if current_user.role != "admin":
raise Forbidden("Admin privileges required")
return current_user
def list_users(admin):
return db.query(User).all()In a real FastAPI application you would connect these with dependencies, but the core idea is:
- Use the user's role.
- Change behavior for admin versus non-admin.
- For admin-only zones, completely reject non-admins with
403 Forbidden.
Summary
Admin permissions are a special type of authorization that protect the most powerful and sensitive operations in your backend.
Key points to remember:
- Store admin status securely, usually with roles or permissions.
- Never trust the frontend or client-sent role data.
- Protect admin endpoints by:
- Authenticating the user.
- Verifying their admin role or permissions.
- Returning
403 Forbiddenwhen they lack rights. - Group admin features logically, often under
/adminprefixes and in separate dashboards. - Log admin actions for auditing and debugging.
- Use least privilege, split admin responsibilities into roles when necessary.
- Add extra safeguards for extremely dangerous actions.
If you design admin permissions carefully, you reduce the risk from both attackers and innocent mistakes, while still giving administrators the tools they need to manage the system.
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!