14.4. Protecting API Endpoints
Table of Contents
Why Protecting API Endpoints Matters
When you put an API on the internet, you are exposing entry points into your system. If you do not protect those endpoints correctly, anyone can:
- Read private data
- Change or delete data
- Impersonate other users
- Abuse resources, for example by creating millions of records
Protecting endpoints is about making sure that only the right people can do the right actions on the right resources.
In this chapter we focus on how to apply authentication and authorization at the endpoint level, how to structure checks, and how to avoid common mistakes. We will not re‑explain basic concepts like what a token is or how passwords are hashed, since those belong to the Authentication and general Authorization chapters.
Three Layers of Endpoint Protection
It helps to think of three layers that protect each request:
| Layer | Question answered | Example |
|---|---|---|
| Network & transport security | Can the request reach us safely? | HTTPS, firewalls, rate limiting |
| Authentication | Who is making this request? | Session cookie, JWT, API key |
| Authorization | Is this caller allowed to do this specific act? | Role check, permission check, ownership check |
In this chapter we focus on the authorization layer, but you always combine it with proper authentication and basic network protections.
Always enforce authorization at the backend. Never trust the frontend to hide or disable actions as your only protection.
A malicious client can always craft requests manually, no matter what your UI shows or hides.
Common Endpoint Protection Patterns
Most protected endpoints fall into one or more of these categories.
1. Authentication required
Only logged in users can access the endpoint.
Examples:
GET /mereturn profile of the currently authenticated userPOST /ordersplace an order for the logged in user
Implementation pattern:
- Check that a valid credential is present (session / JWT / access token).
- Reject if missing or invalid, usually with
$401$ Unauthorized.
Rule: Endpoints that change data should almost never be public. Require authentication by default, then explicitly mark and harden the few that are public.
2. Role based access
Only users with certain roles can access or perform actions.
Examples:
GET /admin/usersonly users with roleadminPOST /productsonly users with roleadminormanager
Typical logic:
if not user.is_authenticated:
401 Unauthorized
if "admin" not in user.roles:
403 Forbidden3. Permission based access
More fine grained than roles. User has specific permissions like "user.read", "product.create".
Examples:
GET /reports/salesrequires permission"reports.view_sales"DELETE /users/{id}requires both"user.read"and"user.delete"
This is similar to roles, but your check is based on a permission list, not a coarse role.
4. Ownership based access
Users can access only their own resources.
Examples:
GET /users/{id}user can only see their own profileGET /orders/{id}user can only see their own orders
Typical logic:
if not user.is_authenticated:
401 Unauthorized
order = get_order(order_id)
if order.user_id != user.id and "admin" not in user.roles:
403 ForbiddenThis chapter will combine these patterns in concrete examples.
Designing Access Rules for Endpoints
Start with a simple question for each endpoint: “Who should be allowed to do this?” and “Under what conditions?”
A helpful habit is to write a short policy rule for each endpoint in plain language.
Example for a blog API:
| Endpoint | Policy description |
|---|---|
GET /posts | Anyone can list published posts. |
GET /posts/{id} | Anyone can view a published post, only owner or admin can view drafts. |
POST /posts | Any authenticated user can create a post. |
PUT /posts/{id} | Only the author or an admin can update a post. |
DELETE /posts/{id} | Only the author or an admin can delete a post. |
GET /admin/users | Only admins can list users. |
Once you are clear on the rule, you can implement it consistently.
Rule: Write down access rules as explicit policies, even informally, before you implement them. This prevents accidental “allow all” logic.
Where to Enforce Authorization
You typically have 3 main places to enforce authorization:
| Place | Pros | Cons |
|---|---|---|
| Controller / endpoint | Very explicit, easy to understand per route | Can become repetitive and messy |
| Middleware / decorators | Reusable, keeps handlers cleaner | Harder to see logic at point of use if overused |
| Service / domain layer | Tied to business logic, hard to bypass | Needs discipline, sometimes feels less “HTTP‑ish” |
A practical approach is to combine them:
- Use middleware / decorators for generic checks like authentication required, role required.
- Use service layer for business specific checks like “user must be owner of this task”.
- Keep the endpoint code small and readable.
Example structure (Python / FastAPI style)
# auth_dependencies.py
def require_auth(user = Depends(get_current_user)):
return user
def require_admin(user = Depends(get_current_user)):
if "admin" not in user.roles:
raise HTTPException(status_code=403)
return user
# services/tasks.py
def assert_can_access_task(user, task):
if task.owner_id != user.id and "admin" not in user.roles:
raise ForbiddenError("Not allowed to access this task")
# endpoints.py
@router.get("/tasks/{task_id}")
def get_task(
task_id: int,
user = Depends(require_auth),
):
task = task_repo.get(task_id)
assert_can_access_task(user, task)
return taskThe endpoint is short, and the rules are centralized in helpers.
HTTP Status Codes for Protected Endpoints
Use consistent HTTP status codes when enforcing protection.
| Situation | Status code | Reason phrase |
|---|---|---|
| No authentication provided, but required | 401 | Unauthorized |
| Invalid or expired token / session | 401 | Unauthorized |
| Authenticated, but not allowed to access the resource | 403 | Forbidden |
| Resource is missing | 404 | Not Found |
Important nuance:
401 Unauthorizedusually means “you are not authenticated correctly”.403 Forbiddenusually means “we know who you are, but you cannot do this”.
Many APIs use 404 Not Found instead of 403 Forbidden for ownership based endpoints to avoid leaking information about resource existence.
Example:
GET /orders/123
- If order 123 exists but belongs to another user:
- Return 404 (pretend it does not exist for this user)
Rule: Prefer 404 over 403 for private resources that a user should not even know exist, to avoid information leaks.
Protecting Different Types of Endpoints
Public endpoints
These are intentionally available without authentication.
Examples:
POST /auth/registerPOST /auth/loginGET /healthGET /productsif your catalog is public
Hardening tips:
- Still validate all input.
- Still enforce rate limiting, especially for login or search.
- Do not reveal internal details in error messages.
Authenticated user endpoints
These require a logged in user, but not a specific role.
Examples:
GET /mePUT /meGET /orderslist current user orders
Typical pattern:
@router.get("/me")
def get_current_profile(user = Depends(require_auth)):
return userMake sure you always derive the user id from the authentication context, not from the client input.
Bad:
GET /users/{id}
# Client can set any id they want.Safer pattern for “my profile”:
GET /me
# Server picks the user from the auth token, not from path.Role restricted admin endpoints
These should be strongly protected and usually not exposed in the same way as public APIs.
Examples:
GET /admin/usersPOST /admin/productsDELETE /admin/users/{id}
Patterns:
- Use a distinct URL prefix like
/admin. - Require both authentication and an admin role or permission.
- In production, consider additional network constraints, for example VPN only, IP allowlist.
Example check:
@router.get("/admin/users")
def list_users(
user = Depends(require_admin),
):
return user_repo.list_all()Ownership based resource endpoints
Typical in applications where each user has their own items.
Examples:
GET /tasks/{id}PUT /tasks/{id}DELETE /tasks/{id}
Recommended steps:
- Authenticate user.
- Load resource by id.
- Check if resource belongs to user, or user is privileged.
- Return resource or perform action.
Example:
@router.get("/tasks/{task_id}")
def get_task(
task_id: int,
user = Depends(require_auth),
):
task = task_repo.get(task_id)
if task is None:
raise HTTPException(status_code=404, detail="Task not found")
if task.owner_id != user.id and "admin" not in user.roles:
# Option A: 404 to hide existence
raise HTTPException(status_code=404, detail="Task not found")
# Option B: 403 to be explicit
# raise HTTPException(status_code=403, detail="Not allowed")
return taskCommon Pitfalls and How to Avoid Them
1. Trusting client provided identifiers
Bad example:
POST /orders
Body: { "user_id": 123, "item_id": 999 }
The client could set any user_id, and create orders for someone else.
Better example:
POST /orders
Body: { "item_id": 999 }
# Server attaches the authenticated user_id.
Rule of thumb: Do not accept user_id or owner_id from the client for owned resources. Derive ownership from the authenticated user.
2. Forgetting authorization on “read only” endpoints
Reading can be as dangerous as writing. For example, reading someone’s personal data, email, or private messages is a serious breach.
Protect views of:
- User profiles with private info
- Internal logs
- Metrics dashboards
- Admin reports
3. Inconsistent checks between endpoints
Example mistake: GET /users/{id} checks that the requester is an admin, but DELETE /users/{id} forgets that check and only verifies authentication.
To avoid this:
- Reuse decorators / middleware or service functions.
- Write tests that verify protection for each sensitive endpoint.
4. Confusing authentication and authorization
Example mistake:
if not user:
# user is None or invalid
raise HTTPException(status_code=403)
Here you returned 403 Forbidden for an invalid login token. It should be 401 Unauthorized. Then 403 is used for authorization problems only.
Consistent semantics help users of your API and make debugging easier.
Protecting Endpoint Parameters
Endpoints often receive identifiers and filters in path parameters, query parameters, or request bodies. All of these can be manipulated by attackers, so treat them as untrusted input.
Example scenarios
- Path parameter misuse
GET /users/{id}
You must not assume that id is the id of the logged in user. Check explicitly that the authenticated user is allowed to see the user with that id.
- Query parameter misuse
GET /orders?user_id=123
An authenticated user might set user_id to another user value. Either:
- Ignore
user_idand always usecurrent_user.id. - Or require a role / permission to filter by other users.
Example:
@router.get("/orders")
def list_orders(
user = Depends(require_auth),
user_id: int | None = None
):
if user_id is not None and "admin" in user.roles:
return order_repo.list_for_user(user_id)
return order_repo.list_for_user(user.id)- Body parameter misuse
PUT /tasks/{id} with body { "title": "X", "owner_id": 5 }
Ignore or validate any sensitive fields like owner_id. Usually, do not allow client to change resource ownership unless you have very specific rules, and even then require extra authorization.
Protecting Collection vs Single Resource Endpoints
Collection endpoints list or search resources, for example GET /orders or GET /users.
Collection endpoints
Typical rules:
- Regular users can only see their own resources.
- Admins can see all resources.
Example:
@router.get("/tasks")
def list_tasks(
user = Depends(require_auth),
):
if "admin" in user.roles:
return task_repo.list_all()
return task_repo.list_for_owner(user.id)Rule: Filtering on the server by user id is not optional. Sending all tasks and relying on the frontend to hide some of them is insecure.
Single resource endpoints
For GET /tasks/{id}, PUT /tasks/{id}, DELETE /tasks/{id}, you must always:
- Load the task by id.
- Verify access.
- Then act.
Never skip the access check just because the collection endpoint already filters by user.
Combining Multiple Protection Rules
Often you need a mix of checks: authenticated, correct role, and correct ownership.
Example: comments on posts.
Rules:
- Any authenticated user can comment on any public post.
- Users can edit their own comments.
- Moderators can edit or delete any comments.
- Deleted posts hide their comments even from owners.
Implementation outline:
@router.post("/posts/{post_id}/comments")
def add_comment(
post_id: int,
body: CommentCreate,
user = Depends(require_auth),
):
post = post_repo.get(post_id)
if not post or not post.is_public:
raise HTTPException(status_code=404)
return comment_repo.create(
post_id=post.id,
author_id=user.id,
text=body.text,
)
@router.put("/comments/{comment_id}")
def update_comment(
comment_id: int,
body: CommentUpdate,
user = Depends(require_auth),
):
comment = comment_repo.get(comment_id)
if not comment:
raise HTTPException(status_code=404)
post = post_repo.get(comment.post_id)
if not post or post.deleted:
raise HTTPException(status_code=404)
if comment.author_id != user.id and "moderator" not in user.roles:
raise HTTPException(status_code=403)
return comment_repo.update(comment_id, body)This illustrates how business rules influence the protection logic.
Rate Limiting and Abuse Protection
Even if an endpoint has correct authentication and authorization, it can still be abused. For example, a user might:
- Call
POST /loginthousands of times to guess passwords. - Call
POST /ordersmany times to spam orders. - Call
GET /searchin a loop to scrape data.
To protect endpoints from abuse, combine authorization checks with rate limiting:
- Limit by IP address for public unauthenticated endpoints.
- Limit by user id or API key for authenticated endpoints.
- Limit sensitive actions more strictly.
Common practical settings:
| Endpoint type | Example limit |
|---|---|
Login (POST /auth/login) | 5 requests per minute per IP/user |
| Password reset | 3 per hour per user/email |
| Search | 60 requests per minute per user |
| Heavy reports | 10 requests per hour per user |
Rate limiting is usually implemented with a tool like Redis and middleware, not in each endpoint, but you should design which endpoints need what limits.
Hiding Sensitive Implementation Details
Error messages and endpoint behavior can leak information to attackers.
Avoid responses like:
{
"detail": "User with id 123 exists but you are not admin"
}Better responses:
- Generic messages:
"Not allowed"or"Resource not found". - Use
404to avoid confirming existence of private resources.
Also:
- Do not expose internal ids if not necessary. You can use random identifiers or slugs for URLs.
- Do not include stack traces or SQL errors in production responses.
Testing Endpoint Protection
To ensure your protection rules really work, you need tests that try to break your own API.
For each sensitive endpoint, test at least:
- Unauthenticated client.
- Authenticated user with correct role / ownership.
- Authenticated user with wrong role / ownership.
- Admin or elevated role user.
Example test cases for GET /tasks/{id}:
| Scenario | Expected result |
|---|---|
| No token | 401 Unauthorized |
| Token of user A, task of user A | 200 OK |
| Token of user A, task of user B | 404 Not Found or 403 Forbidden |
| Token of admin, task of any user | 200 OK |
Automated tests catch mistakes like:
- Removing a decorator accidentally.
- Changing route logic and skipping a check.
- Misconfiguring dependencies.
Summary
Protecting API endpoints is about consistently enforcing authentication and authorization rules at the boundary of your application.
Key practices:
- Require authentication by default for all modifying endpoints.
- Use clear policies per endpoint: who can do what, and why.
- Enforce role checks, permission checks, and ownership checks in reusable helpers.
- Never trust client provided user identifiers for authorization decisions.
- Use appropriate HTTP status codes:
401for auth problems,403/404for access problems. - Limit abuse with rate limiting, especially on public and sensitive endpoints.
- Test all important endpoints with multiple roles and scenarios.
If you design endpoint protection systematically and implement it in a structured way, you greatly reduce the risk of data leaks and unauthorized actions in your backend.
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!