30.3. Role-Based Authorization
Table of Contents
Understanding Role-Based Authorization
Role-based authorization controls what a user is allowed to do in your system based on their assigned roles, such as user, admin, or moderator. In this chapter, you will see how to design and implement role-based authorization for a backend authentication system.
We focus on how roles interact with authentication, sessions, and tokens, not on basic authorization theory, which is covered in the general Authorization section.
Key idea:
Authentication answers: “Who are you?”
Role-based authorization answers: “Given who you are, what are you allowed to do?”
Defining Roles in an Authentication System
Before you can authorize anything, you must define which roles exist and what they mean.
Typical roles in a simple authentication system might be:
| Role | Description | Example Permissions |
|---|---|---|
user | Regular logged-in user | Manage own profile, create tasks/orders |
admin | System administrator | Manage all users, change system settings |
moderator | Content or user management without full power | Approve content, suspend users (limited) |
guest | Not logged in, or very limited account | Read public content only |
You do not want to hardcode too many roles too early. Start small, for example:
useradmin
You can extend the list later if needed.
Storing Roles
You must store a user’s role(s) somewhere persistent so that the backend can check them on each request.
Single-role vs multi-role
Two design choices:
- Single role per user
- Each user has exactly one role, such as
useroradmin. - Simple to implement and reason about.
- Multiple roles per user
- A user can have roles like
["user", "moderator"]. - More flexible, but slightly more complex.
For many beginner projects, start with a single role per user, then extend if needed.
Example user table / model
If you use a relational database and a simple single-role setup:
| Column | Type | Example Value |
|---|---|---|
| id | integer | 23 |
| text | "alice@example.com" | |
| password | text (hash) | "$2b$..." |
| role | text | "user" or "admin" |
In Python with an ORM, a user model might look like:
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
email = Column(String, unique=True, index=True, nullable=False)
password_hash = Column(String, nullable=False)
role = Column(String, nullable=False, default="user")If you use multi-role, you typically have a separate table, for example:
rolestable: (id,name)user_rolestable: (user_id,role_id)
But for this chapter, we will mostly talk in terms of a single role field.
Assigning Roles During Registration
Role-based authorization depends on consistent rules for how roles are assigned.
Default role on registration
In most authentication systems, new users get a default, minimal role such as user.
Example logic during registration:
- User sends
email,passwordto a/registerendpoint. - Backend hashes the password.
- Backend assigns
role="user"for all new users. - Backend saves the user in the database.
Example pseudo-code:
def register_user(email: str, password: str) -> User:
hashed = hash_password(password)
user = User(
email=email,
password_hash=hashed,
role="user" # default role
)
db.add(user)
db.commit()
db.refresh(user)
return user
Rule: Never let a registration endpoint accept the role from the client.
If the client can send role="admin" during registration, anyone can create an admin account.
If you need to create admins, you can:
- Insert them manually in the database, or
- Provide a secure admin-only endpoint to change roles, or
- Use a one-time setup script or "first user is admin" logic for development only.
Including Roles in Tokens or Sessions
After a user logs in, you need to carry the user’s role with their authenticated identity so that each request can be authorized correctly.
For token-based authentication (JWT)
If you use JWT (JSON Web Tokens) as described in this project, you can embed the role in the token claims.
When you authenticate a user and issue an access token:
- Load user from database.
- Read user’s
idandrole. - Put them into the JWT payload.
Example FastAPI-style snippet:
def create_access_token(user: User) -> str:
payload = {
"sub": str(user.id),
"role": user.role,
"exp": datetime.utcnow() + timedelta(minutes=15)
}
token = jwt.encode(payload, SECRET_KEY, algorithm="HS256")
return tokenOn each request:
- Extract the token from the
Authorizationheader. - Decode the JWT.
- Read the
rolefrom the payload. - Use this role to check if the user may perform the requested action.
Rule: Treat the role claim in a JWT as trusted only if:
- The JWT is signed with a secret or private key you control, and
- You verify the signature on every request.
Never accept client-provided role data without verification.
For session-based authentication
If you use sessions:
- Store the user’s
idandroleinside the server-side session store, for example in Redis, or - Use a signed session cookie that includes role.
Example session data:
{
"user_id": 23,
"role": "admin"
}Then on each request, look up the session and get the role from there.
Enforcing Role-Based Access on Endpoints
Once you can identify the user and their role during a request, you can protect endpoints based on role.
Basic pattern
On each protected route:
- Authenticate the user.
- Get user’s role.
- Check if the role is in the set of allowed roles.
- If yes, continue; if not, return a 403 Forbidden response.
HTTP status codes for authorization:
401 Unauthorizedis for unauthenticated (no valid credentials).403 Forbiddenis for authenticated but not allowed (role not sufficient).
Example: decorator-style check (language-agnostic idea)
Imagine a simple require_role helper:
def require_role(allowed_roles):
def decorator(handler):
def wrapper(request, *args, **kwargs):
user = authenticate_request(request)
if user is None:
return Response(status_code=401)
if user.role not in allowed_roles:
return Response(status_code=403)
return handler(request, *args, **kwargs)
return wrapper
return decoratorThen you can use it like this:
@require_role(["admin"])
def delete_user(request, user_id):
# only admins get here
...Example: endpoint rules table
Consider these API endpoints:
| Endpoint | Action | Allowed Roles |
|---|---|---|
GET /me | Get current user profile | user, admin |
PUT /me | Update own profile | user, admin |
GET /users | List all users | admin |
DELETE /users/{id} | Delete any user | admin |
POST /auth/login | Log in | all (no auth required) |
Some examples of decisions:
- Regular
usercan view and update only their own profile. - Only
admincan list or delete other users.
For a more advanced design, you may combine role-based rules with resource ownership, which is covered in the Authorization section.
Example: Role-Based Authorization Flow with JWT
Let us put the pieces together in a simple flow for a JWT-based auth system:
- Registration
- User sends email and password.
- Backend creates user with
role="user". - Admin creation
- You manually update a record in the database:
UPDATE users SET role = 'admin' WHERE email = 'admin@example.com';- Or use an admin-only endpoint like
POST /admin/users/{id}/promote.
- Login
- User sends email and password to
/auth/login. - Backend verifies password.
- Backend generates a JWT that includes:
{
"sub": "23",
"role": "admin",
"exp": 1699999999
}- Authorized request
- Client sends
Authorization: Bearer <token>header. - Backend decodes JWT and reads
subandrole. - Backend loads user if needed, or trusts the role claim if token is valid.
- Backend checks:
- Is user authenticated? If not,
401. - Is user role in allowed roles for this endpoint? If not,
403. - If allowed, executes business logic.
Fine-Grained Role Rules
Different parts of your authentication system may require different roles.
Example: Role-based rules for auth endpoints
| Endpoint | Description | Required Role |
|---|---|---|
POST /auth/register | Register new account | Public (no auth) |
POST /auth/login | Log in and get access token | Public (no auth) |
POST /auth/logout | Invalidate session or token | user or admin |
GET /auth/me | Get current user info | user or admin |
PATCH /auth/me | Update own info | user or admin |
GET /admin/users | List all users | admin |
PATCH /admin/users/{id}/role | Change user’s role | admin |
DELETE /admin/users/{id} | Delete any user | admin |
Specific examples:
- A regular user should not be able to change their role to admin.
- Only an admin can promote or demote other users.
Example check inside an endpoint:
def change_user_role(current_user: User, target_user_id: int, new_role: str):
if current_user.role != "admin":
raise HTTPException(status_code=403, detail="Admins only")
# now admin can change roles
...Avoiding Common Pitfalls
Role-based authorization is simple in theory, but there are some frequent mistakes.
1. Relying only on the frontend
You might hide admin buttons in the frontend, but this is not enough.
- Attackers can still send requests directly with tools like Postman or curl.
- Never trust the UI to enforce permissions.
Rule: Every permission check must be enforced in the backend, not only in the frontend.
2. Storing role in an unsigned client-side token
If you store the role in a JSON object on the client without signing it:
{
"user_id": 23,
"role": "admin"
}The client can simply modify it to:
{
"user_id": 23,
"role": "admin"
}and gain unauthorized admin access.
You must:
- Use signed JWTs or
- Use server-side sessions where role is stored on the server.
3. Not checking both role and ownership
Sometimes you need both:
- Role check, for example users must be at least
userto access a resource. - Ownership check, for example users can only change their own data.
Example:
def update_user(current_user: User, user_id: int, data):
if current_user.role != "admin" and current_user.id != user_id:
# not admin and not the owner
raise HTTPException(status_code=403, detail="Not allowed")
# user is admin or owner
...4. Hardcoding role names everywhere
If you write strings like "admin" or "user" all over your code, it becomes hard to change later.
Instead:
- Define constants, or
- Use an enum.
Example constants:
ROLE_USER = "user"
ROLE_ADMIN = "admin"
ALLOWED_ADMIN_ROLES = {ROLE_ADMIN}You can then use them consistently.
Evolving Beyond Simple Roles
In this chapter we focus on role-based authorization: simple sets of roles with fixed meanings.
As your project grows, you may need more flexible strategies that are covered in the Authorization section, for example:
- Role-Based Access Control (RBAC) with multiple roles per user.
- Permission-based access control, where you have fine-grained permissions such as
can_delete_user,can_update_order. - Attribute-based access control, which uses attributes of the user and resource.
- Combining roles with scope-based tokens (for example,
scope: "read:users").
For this authentication project, a clean and simple role-based system with at least user and admin is usually enough.
Putting It All Together in Your Auth System
When you integrate role-based authorization in this project, keep these steps in mind:
- Design your roles
- Start with at least
userandadmin. - Decide whether users can have one or many roles.
- Store roles
- Add a
rolefield to your user model or a user-roles relation. - Assign roles
- Registration sets
role="user"automatically. - Admin creation is controlled and not open to the public.
- Include roles in identity
- JWT: put
roleinto the token payload. - Sessions: store
rolein session data. - Protect endpoints
- Decide allowed roles for each route.
- Implement role checks in middleware, decorators, or route dependencies.
- Use
401for unauthenticated and403for unauthorized. - Test your authorization
- Test that
usercannot access admin endpoints. - Test that
admincan access both user and admin endpoints. - Test that changing frontend code does not bypass backend checks.
Once you have these pieces, your authentication system will not only know who the user is, but also reliably control what they are allowed to do.
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!