15.6. CORS
Table of Contents
Why CORS Exists
When your browser loads a web page, that page can run JavaScript. That JavaScript can send HTTP requests, for example with fetch or XMLHttpRequest.
Without any protection, any website could:
- Call any API where you are logged in.
- Read the response data.
- Perform actions as you.
Browsers implement a same origin policy to reduce this risk.
An origin is:
scheme(protocol) +host(domain) +port
For example:
| URL | Origin |
|---|---|
https://example.com/index.html | https://example.com |
https://api.example.com/users | https://api.example.com |
http://example.com:8080/hello | http://example.com:8080 |
JavaScript in a page from https://example.com is normally not allowed to read responses from https://api.example.com or http://example.com:8080.
But in modern web development, frontend and backend often live on different origins:
- Frontend during development:
http://localhost:3000 - Backend API:
http://localhost:8000
We need a controlled way to say:
"This backend allows that origin to access it."
This mechanism is CORS, Cross Origin Resource Sharing.
CORS is a browser security feature. The server participates by sending special HTTP headers. Other clients, such as Python scripts, Postman, or curl, completely ignore CORS. They can call your API without any CORS issues.
CORS is enforced only by browsers. It is a client-side security restriction that the server can relax in a controlled way by sending CORS headers.
Basic CORS Flow
Imagine this situation:
- Frontend origin:
http://localhost:3000 - Backend API:
http://localhost:8000
Frontend code:
fetch('http://localhost:8000/api/items')
.then(r => r.json())
.then(console.log);From the browser's view, this is a cross origin request. The browser:
- Adds an
Originheader to the request:
Origin: http://localhost:3000- Sends the request to
http://localhost:8000. - Waits for the server response.
- Checks the server's CORS headers.
- If allowed, the browser gives the JavaScript access to the response data.
- If not allowed, the browser blocks JavaScript from reading the response and shows a CORS error in the console.
The server decides whether to allow this by returning headers such as:
Access-Control-Allow-Origin: http://localhost:3000
If the Access-Control-Allow-Origin value matches the Origin of the request, the browser allows access. If not, it blocks it.
Important: The request is usually still received by the server. CORS only affects whether the browser exposes the response to JavaScript.
Important CORS Headers
Request Headers
When a browser makes a cross origin request, it adds at least:
Origin- Sometimes other CORS related headers for preflight, which we will cover later.
Example:
GET /api/items HTTP/1.1
Host: localhost:8000
Origin: http://localhost:3000Response Headers
The server responds with CORS headers to indicate what is allowed.
Access-Control-Allow-Origin
This is the core header.
Examples:
Access-Control-Allow-Origin: http://localhost:3000or
Access-Control-Allow-Origin: *Rules:
- Must either be:
- A single origin value, for example
https://myfrontend.com, or *to allow every origin.- You cannot put multiple origins separated by commas. If you want to support multiple specific origins, you must decide per request which single origin to return.
Rule: Access-Control-Allow-Origin must be either exactly one origin or *. Never try Access-Control-Allow-Origin: https://a.com, https://b.com.
Access-Control-Allow-Credentials
Controls whether the browser is allowed to send credentials such as:
- Cookies
- HTTP auth
- TLS client certificates
Example:
Access-Control-Allow-Credentials: trueImportant restrictions:
- If you allow credentials, you cannot use
Access-Control-Allow-Origin: *. - You must use a specific origin value.
Rule: If Access-Control-Allow-Credentials: true then you must not use * for Access-Control-Allow-Origin. Use a specific origin instead.
Access-Control-Expose-Headers
By default, JavaScript can only read a limited set of response headers in cross origin responses.
To allow access to custom headers, you specify them:
Access-Control-Expose-Headers: X-Total-Count, X-Request-IdThen frontend code can do:
const count = response.headers.get('X-Total-Count');This is useful for pagination metadata, request IDs, or other custom information.
Simple vs Preflight Requests
Browsers do not treat all cross origin requests the same. There are two categories:
- Simple requests
- Preflighted requests
Simple Requests
A cross origin request is "simple" if it satisfies strict conditions:
- Method is one of:
GETHEADPOST- Request headers are only a limited set of "simple headers":
AcceptAccept-LanguageContent-LanguageContent-Type, but only with:text/plainmultipart/form-dataapplication/x-www-form-urlencoded- No custom headers like:
X-Auth-TokenX-Requested-WithX-Custom
For simple requests, the browser directly sends the request, then checks the CORS headers on the response.
Example of a simple GET:
GET /api/items HTTP/1.1
Host: api.example.com
Origin: https://frontend.example.comServer response:
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://frontend.example.com
Content-Type: application/json
[{"id": 1, "name": "Item 1"}]If the origin matches, the browser gives the response to JavaScript.
Preflight Requests
If the request does not meet the "simple" rules, the browser sends an extra request before the real one. This is the preflight request.
The preflight uses the OPTIONS method and asks the server:
"If I later send a request like this, will you allow it?"
The server must reply and say which methods and headers are allowed.
When preflight is used
Preflight is triggered when you use:
- HTTP methods:
PUTPATCHDELETEOPTIONSwith custom requests- Custom headers:
AuthorizationX-Auth-Token- Any non simple header
- Non simple
Content-Type, for example: application/json
Example: Preflight Sequence
Frontend code:
fetch('https://api.example.com/items/123', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer abc123'
},
body: JSON.stringify({ name: 'New name' })
});Browser sends a preflight request:
OPTIONS /items/123 HTTP/1.1
Host: api.example.com
Origin: https://frontend.example.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: Content-Type, AuthorizationServer responds:
HTTP/1.1 204 No Content
Access-Control-Allow-Origin: https://frontend.example.com
Access-Control-Allow-Methods: GET, POST, PUT, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Allow-Credentials: true
Access-Control-Max-Age: 600
If the browser accepts this response, it then sends the actual PUT request.
Actual request:
PUT /items/123 HTTP/1.1
Host: api.example.com
Origin: https://frontend.example.com
Content-Type: application/json
Authorization: Bearer abc123
{"name": "New name"}The server should respond with CORS headers again.
Preflight Response Headers
Important headers in the preflight response:
Access-Control-Allow-Origin: as beforeAccess-Control-Allow-Methods: which methods are allowed
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONSAccess-Control-Allow-Headers: which custom headers can be used
Access-Control-Allow-Headers: Content-Type, Authorization, X-Request-IdAccess-Control-Max-Age: how long (in seconds) the browser can cache this preflight result
Access-Control-Max-Age: 3600
Caching preflight responses reduces the number of extra OPTIONS requests.
Rule: For preflight to succeed, the server must include:
Access-Control-Allow-Originwith a matching origin or*(if no credentials), andAccess-Control-Allow-Methodsthat includes the requested method, andAccess-Control-Allow-Headersthat includes all requested headers.
CORS and Credentials
Many APIs require authentication or rely on cookies for sessions.
From the browser side, there are two separate questions:
- Is the browser allowed to send credentials with a cross origin request?
- Is JavaScript allowed to read the response when credentials are involved?
To send credentials:
- The frontend must set
credentialsinfetch. - The server must allow credentials.
Example frontend with cookies:
fetch('https://api.example.com/profile', {
credentials: 'include', // send cookies
});Server response:
Access-Control-Allow-Origin: https://frontend.example.com
Access-Control-Allow-Credentials: trueIf anything is wrong, the browser will block the response.
Table of common fetch credentials options:
| Value | Meaning |
|---|---|
omit | Never send cookies or auth info |
same-origin | Send credentials only when origin is the same |
include | Always send credentials, even for cross origin calls |
Important combinations:
- If the response has
Access-Control-Allow-Origin: *andAccess-Control-Allow-Credentials: true, the browser will treat it as invalid. - For credentialed CORS, you must use a specific origin value.
Rule: For CORS requests with cookies or auth:
- Frontend:
credentials: 'include' - Server:
Access-Control-Allow-Origin: <exact frontend origin>
andAccess-Control-Allow-Credentials: true
Common CORS Misconfigurations
Allowing Everything in Production
It is tempting to "fix" CORS errors by adding:
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: *
Access-Control-Allow-Headers: *
Access-Control-Allow-Credentials: trueThis can silently disable important protections. Some of these combinations are invalid anyway.
Typical problems:
- Any website can make requests to your API from the user's browser.
- If you do not use cookies or rely only on token in header, other sites might still be able to trigger actions if users paste tokens or if there are other flows.
- You may think you are protected, but you are not.
Better approach:
- In development, you can use
*without credentials for convenience. - In production, always whitelist specific origins.
Example safe configuration for production:
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Allow-Credentials: trueForgetting CORS on Error Responses
Some frameworks only add CORS headers for successful responses.
In that case, you see logs that show the server responded with 401 or 500, but the browser displays a CORS error, not the real error.
You must ensure:
- CORS headers are present on all responses, including errors handled by exception handlers.
For example, in a middleware that sets CORS headers on every response.
Not Handling Preflight Requests
Some backends:
- Reject
OPTIONSrequests with 404, 405, or similar. - Only handle GET, POST, etc.
For non simple cross origin requests, the browser will never even send the main request if preflight fails.
Solution:
- Add explicit handling for
OPTIONSrequests, or - Use a CORS middleware that auto responds to preflight.
Mismatched Origin Values
Common mistakes:
- Extra trailing slash:
- Correct:
https://app.example.com - Wrong:
https://app.example.com/ - Using
httpinstead ofhttpsin configuration. - Forgetting specific ports in development:
- Frontend:
http://localhost:3000 - Backend returns:
http://localhost(does not match)
Browsers compare origin exactly: scheme, host, and port must match.
CORS in Development vs Production
In development, typical setup:
http://localhost:3000React frontendhttp://localhost:8000FastAPI backend
You can be more permissive here, for example:
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: *
Access-Control-Allow-Headers: *As long as you do not use cookies or credentialed sessions.
In production, typical setup:
- API at
https://api.example.com - Web app at
https://app.example.com
Better configuration:
- Allow only
https://app.example.com. - Allow credentials if needed.
- Limit methods and headers to what is actually used.
Example:
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization, X-Request-Id
Access-Control-Max-Age: 3600It is also common to support more than one frontend, for example:
- Main app:
https://app.example.com - Admin app:
https://admin.example.com
The server then must:
- Inspect the
Originheader. - Check if it belongs to an allowed list.
- Echo back the same origin in
Access-Control-Allow-Origin.
Pseudo code logic:
ALLOWED_ORIGINS = {
"https://app.example.com",
"https://admin.example.com",
}
origin = request.headers.get("Origin")
if origin in ALLOWED_ORIGINS:
response.headers["Access-Control-Allow-Origin"] = origin
response.headers["Vary"] = "Origin"
Vary: Origin tells caches that the response may change depending on the Origin request header.
CORS and Security Perspective
CORS does not protect your API from malicious scripts using curl or Postman.
CORS is about one question:
"Can JavaScript in a browser page from origin A read responses from origin B?"
From the backend security perspective:
- CORS controls who can read responses in a browser.
- Authentication and authorization control who can perform actions, regardless of CORS.
You still need:
- Authentication, tokens, sessions.
- Proper authorization checks.
- CSRF protection when you use cookies.
- Input validation.
But CORS is still important, because:
- Without CORS restrictions, your API could be easily used by any website as a free backend, especially if you do not require authentication.
- With cookie based login and weak CORS, a malicious website could act on behalf of logged in users if you also lack CSRF protection.
Useful rule of thumb:
Rule: CORS is not a substitute for authentication or CSRF protection. Treat CORS as an additional browser level safety belt, not as the main lock on your API.
Practical CORS Examples
Example 1: Public Read Only API
You have a public API for reading blog posts:
- No authentication.
- Safe methods only:
GET.
Goal:
- Allow all websites to fetch public posts.
- Do not worry about cookies.
Configuration example:
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET
Since you do not accept credentials, * is acceptable here.
Example 2: Single Page App with Login Token in Header
Setup:
- SPA at
https://app.example.com - API at
https://api.example.com - Auth token is sent in
Authorizationheader:Bearer <token>
This triggers preflight for requests with Authorization.
You want:
- Only
https://app.example.comcan access your API from browser JavaScript. - No cookies, only tokens in headers.
Configuration example:
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 600
No Access-Control-Allow-Credentials, since you do not use cookies.
Example 3: Cookie Based Session
Setup:
- Frontend:
https://app.example.com - Backend:
https://api.example.com - Login sets a cookie like
sessionid=...; Secure; HttpOnly; SameSite=None.
SameSite=None is required to allow cookies to be sent in cross site contexts. That also requires Secure.
In the frontend, you must always use:
fetch('https://api.example.com/profile', {
credentials: 'include',
});Server CORS headers:
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-TypeYou must also implement CSRF protection, but that belongs to other security topics in the course.
Summary
- Browsers enforce same origin policy for security.
- CORS is a protocol that allows servers to explicitly relax this policy for selected origins.
- Key headers:
Originin requests.Access-Control-Allow-Originin responses.- Additional headers like
Access-Control-Allow-Methods,Access-Control-Allow-Headers,Access-Control-Allow-Credentials,Access-Control-Max-Age. - Simple requests skip preflight. Others trigger a preflight
OPTIONSrequest. - For credentialed CORS:
- Use
credentials: 'include'on the frontend. - Return a specific origin and
Access-Control-Allow-Credentials: trueon the backend. - Do not rely on CORS as your only security control. It only affects browser JavaScript access, not direct HTTP clients.
Understanding CORS helps you:
- Fix common "CORS error" messages in browsers.
- Configure your backend safely so that only trusted frontends can use it from browsers.
- Keep development flexible while keeping production secure.
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!