15.2. HTTPS and TLS
Table of Contents
Why HTTPS Matters for Backend Developers
Most modern websites use HTTPS by default. As a backend developer you must understand what it actually does, why it is required, and how it affects your API design and deployment.
HTTP is plain text. Anyone who can watch the traffic between client and server can read and modify everything. HTTPS is simply HTTP over TLS, which adds encryption and security on top of HTTP.
Backends that handle logins, tokens, payments, or personal data must use HTTPS in production. Browsers and mobile apps also expect HTTPS for modern features like Service Workers and HTTP/2.
Always require HTTPS in production for any application that deals with authentication or user data.
In this chapter you will learn the basics of TLS and certificates, what security guarantees HTTPS provides, and what you must do in your backend code and infrastructure to use HTTPS correctly.
What HTTPS Actually Protects
HTTPS gives three main security properties:
| Property | What it means | Example |
|---|---|---|
| Confidentiality | Attackers cannot read the traffic | Passwords or tokens stay private |
| Integrity | Traffic cannot be silently modified in transit | JSON responses cannot be altered |
| Authentication | Client can verify the server it talks to | api.example.com is really yours |
Confidentiality
With HTTP, a network observer can see:
- Requested URLs
- Headers and cookies
- Request bodies (passwords, tokens, form data)
- Response bodies (HTML, JSON, files)
With HTTPS:
- The URL path and query, headers, and body are encrypted.
- Only a small part of the request is visible, such as the destination IP and the server name (SNI) that is being requested.
Example:
- HTTP login:
- Someone on the same Wi‑Fi can read
POST /login, the username and password. - HTTPS login:
- The attacker can see that you connect to
example.com, but not which endpoint or credentials.
Integrity
Without HTTPS, an attacker can:
- Inject JavaScript into HTML pages.
- Modify JSON responses from your API.
- Strip security headers such as
Strict-Transport-Security.
With HTTPS, if any byte is changed in transit, the TLS layer detects it and the connection is aborted.
Example:
- Your API returns:
{"user_id": 123, "role": "user"}- On HTTP, an attacker could change
"role": "user"to"role": "admin"before it reaches the client. - On HTTPS, this alteration would be detected and rejected.
Authentication (of the server)
HTTPS uses certificates to prove that the client is indeed talking to api.example.com, not to an impostor.
This prevents:
- Man-in-the-middle attacks that pretend to be your server.
- Transparent proxies that terminate your TLS and re-route traffic.
Note that this authenticates the server to the client, not necessarily the client to the server. For client authentication you use sessions, tokens, or mutual TLS, which is out of scope here.
TLS Basics: The Protocol Under HTTPS
TLS (Transport Layer Security) is the protocol that provides the security for HTTPS.
- HTTP + TLS over TCP = HTTPS
- SMTP + TLS over TCP = secure email transfer
- Many application protocols can run "over" TLS
You do not implement TLS in application code yourself. Your web server or reverse proxy (for example Nginx, Caddy, Apache, Traefik, a cloud load balancer) handles TLS.
However, you need to understand the pieces so you can configure it correctly.
TLS Versions
Main versions you will see:
| Version | Status |
|---|---|
| SSL 2/3 | Obsolete and insecure, never use |
| TLS 1.0 | Deprecated |
| TLS 1.1 | Deprecated |
| TLS 1.2 | Widely used, still considered secure |
| TLS 1.3 | Modern, faster, preferred |
Only enable TLS 1.2 and 1.3 for public internet services. Disable SSL and older TLS versions.
In practice, most recommended server configurations today:
- Allow TLS 1.2 and 1.3.
- Prefer TLS 1.3 when possible.
Very High-Level TLS Handshake Overview
A full handshake is complex, but conceptually:
- Client hello
The client says: I want to talk using TLS, here are the cipher suites and TLS versions I support, and the server name (SNI). - Server hello
The server picks the protocol version and cipher suite and sends: - Its certificate (containing its public key and domain).
- Some cryptographic parameters.
- Key exchange
Client and server use asymmetric cryptography to establish a shared secret. With modern TLS, this is usually ephemeral Diffie‑Hellman. - Session keys derived
Both sides derive symmetric keys from the shared secret. - Secure channel established
From then on, all data is encrypted and authenticated with symmetric cryptography.
Mutual authentication (where the client also presents a certificate) is possible but rare for public APIs. Typically only the server is authenticated.
Certificates and Certificate Authorities
TLS uses public key cryptography. Each server has:
- A private key that must be kept secret.
- A public key, embedded in a certificate that can be shared.
What Is a TLS Certificate?
A certificate binds:
- A domain name (for example
api.example.com) - To a public key
- And is signed by a Certificate Authority (CA).
In simplified form, a certificate says:
"The owner of api.example.com controls this public key, and I, the CA, vouch for it."
The browser or HTTP client verifies this statement using the CA's root certificate already built into the operating system or browser.
Fields you will commonly see in a certificate
- Subject: Domain name or organization.
- Subject Alternative Name (SAN): Additional domains or wildcards, for example
*.example.com. - Issuer: The CA that signed the certificate.
- Validity: Not before / not after dates.
- Public key: The server's public key.
- Signature: The CA's cryptographic signature over the certificate data.
Certificate Authorities (CAs)
A CA is a trusted third party that:
- Verifies that you control the domain (for example by DNS record or HTTP challenge).
- Issues a signed certificate.
- The CA's root certificate is trusted by browsers and operating systems.
Popular CAs include:
- Let’s Encrypt (free, automated)
- DigiCert
- GlobalSign
- Sectigo
Do not create self-signed certificates for public production sites. Browsers will warn users, and security is weakened. Use a CA-issued certificate.
Self-signed certificates are fine for internal testing or secure internal systems where you control the trust store.
How the Browser Verifies HTTPS
When a browser connects to https://api.example.com:
- It receives the server's certificate.
- It checks:
- Is the certificate issued by a CA that is in my trusted list?
- Is the certificate currently valid (date range)?
- Does the certificate's domain match the requested domain (
api.example.com)? - Is the certificate signature valid?
- If any of these checks fail, the browser displays a warning such as "Your connection is not private".
As a backend developer, your job is to ensure:
- Your server presents a valid certificate.
- The domain name in the certificate matches your API or site.
- The certificate has not expired.
- Intermediate certificates are configured correctly so clients can build a trust chain from your certificate to a trusted root CA.
How HTTPS Affects Your Backend Code
Most of your HTTPS work happens in server and infrastructure configuration, not inside your Python / application code. However, there are some important points that affect your backend logic.
Absolute vs Relative URLs
When generating URLs in responses or templates, avoid hardcoding http://. Use:
- Relative URLs where possible, for example
/logininstead ofhttp://example.com/login. - Configuration or environment variables for the scheme and host.
If your app runs behind a reverse proxy that terminates TLS, your backend might only see plain HTTP on the internal network. For example:
- Client <HTTPS> Nginx <HTTP> FastAPI
In that case, the backend must rely on headers like X-Forwarded-Proto to know that the original request was HTTPS. Frameworks often have configuration flags to handle this correctly.
Secure Cookies
Cookies that carry authentication or sensitive data must be configured to be used only over HTTPS.
Use these flags:
Secure
Browser sends the cookie only over HTTPS, not over plain HTTP.HttpOnly
JavaScript cannot read the cookie usingdocument.cookie. This helps prevent some XSS attacks from stealing session cookies.SameSite
Controls cross-site cookie sending. For login and CSRF protection you often useSameSite=LaxorSameSite=Strict.
Example of a secure cookie in a response header:
Set-Cookie: session_id=abc123;
Path=/;
HttpOnly;
Secure;
SameSite=Lax
Never send authentication cookies without the Secure and HttpOnly flags in production.
HTTP Strict Transport Security (HSTS)
HSTS tells the browser:
"For this domain, always use HTTPS for the next N seconds, even if the user types http:// or clicks an old http:// link."
You set this with the Strict-Transport-Security header, for example:
Strict-Transport-Security: max-age=31536000; includeSubDomains; preloadMeaning:
- For 1 year (
31536000seconds): - Only use HTTPS.
- Apply this to all subdomains.
- The domain wants to be included in browser preload lists.
Benefits:
- Prevents downgrade attacks where an attacker tries to redirect users from HTTPS to HTTP.
- Helps ensure that users always use secure connections once they have visited the site once.
Use HSTS only when:
- Your site is fully HTTPS.
- You are confident you will not need HTTP anymore, especially for that domain and subdomains.
Common HTTPS Deployment Patterns
You will often not terminate TLS inside your application server. Instead, you use a reverse proxy or load balancer.
Pattern 1: TLS Termination at Reverse Proxy
Typical stack:
- Internet
- Nginx (handles TLS, HTTPS)
- Uvicorn / Gunicorn (application server, HTTP on localhost)
Flow:
- Client connects to
https://api.example.com. - Nginx handles the TLS handshake and decrypts the traffic.
- Nginx forwards the HTTP request to
http://127.0.0.1:8000. - Application handles the request and sends HTTP response back to Nginx.
- Nginx encrypts it and sends to the client as HTTPS.
Advantages:
- Application code does not deal with TLS directly.
- Easier certificate management and renewal.
- Nginx can handle many connections efficiently.
Pattern 2: TLS Termination at a Cloud Load Balancer
If you use a cloud provider (AWS, GCP, Azure), you might use:
- An HTTP(S) load balancer with a certificate managed by the cloud.
- Containers or VMs behind it that only speak HTTP.
Example on AWS:
- AWS Application Load Balancer terminates TLS with a certificate from AWS Certificate Manager (ACM).
- It forwards HTTP traffic to your ECS / Kubernetes / EC2 services.
From your application's perspective, requests arrive as plain HTTP on an internal network, but externally users only see HTTPS.
Pattern 3: End-to-end TLS
In more secure environments you may:
- Terminate TLS at a load balancer, then
- Use TLS again between the load balancer and backend servers.
This is common in regulated environments where traffic must be encrypted even on internal networks.
Practical HTTPS Guidelines for Backend Developers
When to Use HTTPS
- For all production websites and APIs.
- For any route that:
- Handles login or registration.
- Receives or sends personal or sensitive data.
- Sets or reads authentication cookies.
- Uses tokens like JWTs in headers or bodies.
Redirect HTTP to HTTPS
If clients connect to http://example.com, redirect them to https://example.com.
Example HTTP response:
HTTP/1.1 301 Moved Permanently
Location: https://example.com/At your reverse proxy, you can:
- Listen on port 80 (HTTP).
- Respond with a 301 or 308 redirect to the HTTPS URL.
Do not serve content on HTTP and HTTPS at the same time. That can confuse clients and weaken security.
Check Security After Deployment
After you set up HTTPS:
- Use a browser to check:
- No security warnings.
- The lock icon or security badge.
- Use tools like:
- SSL Labs SSL Server Test (by Qualys).
curl -v https://your-domain.- Confirm:
- Only TLS 1.2 and 1.3 are enabled.
- Strong cipher suites are preferred.
- Certificate chain is complete.
- Certificate is not expired and matches domain.
Example: HTTPS Impact on a Simple FastAPI App
Imagine you have a basic FastAPI app:
from fastapi import FastAPI
from fastapi.responses import JSONResponse
app = FastAPI()
@app.get("/secure-data")
def secure_data():
return JSONResponse({"secret": "only-over-https"})Local development
You often run:
uvicorn main:app --reload --host 0.0.0.0 --port 8000
And access http://localhost:8000/secure-data. This is fine for local development and testing. For real users, you still deploy behind HTTPS.
Production deployment behind Nginx
- Nginx has your certificate.
- Nginx is configured like:
server {
listen 80;
server_name api.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name api.example.com;
ssl_certificate /etc/letsencrypt/live/api.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/api.example.com/privkey.pem;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-Proto https;
}
}- Your app is still just listening on HTTP internally, but clients always use HTTPS.
- In your application, if you need to know whether the request was HTTPS, configure FastAPI / the ASGI server to trust
X-Forwarded-Protofrom Nginx (for example by usinguvicorn --proxy-headersor similar).
Common HTTPS Pitfalls
Mixed Content
If your HTML page is loaded over HTTPS, but it tries to load resources over HTTP, such as:
<script src="http://example.com/script.js"></script>Browsers will block or warn about "mixed content".
Always use:
https://URLs for external resources.- Relative URLs for your own resources.
Using HTTP for API Endpoints in JavaScript
If your frontend is served over HTTPS, calling an HTTP API endpoint from JavaScript is insecure and often blocked.
Example problematic code:
fetch("http://api.example.com/data")Use:
fetch("https://api.example.com/data")or a relative path if you serve frontend and backend from the same origin.
Expired Certificates
Certificates have an expiration date. If you use Let’s Encrypt, certificates are valid for 90 days. You must have an automatic renewal process.
If your certificate expires:
- Browsers will show serious security warnings.
- Many HTTP clients will refuse to connect.
Summary
- HTTPS is HTTP over TLS and provides confidentiality, integrity, and authentication of the server.
- TLS uses certificates issued by trusted CAs to prove that a domain really belongs to the server you are talking to.
- Modern servers should only enable TLS 1.2 and 1.3.
- In most setups, a reverse proxy or load balancer terminates TLS, not your application code.
- As a backend developer, you must:
- Ensure all production traffic uses HTTPS.
- Redirect HTTP to HTTPS.
- Use secure cookies with
SecureandHttpOnly. - Consider HSTS when you are fully on HTTPS.
- Avoid mixed content issues and insecure API calls from HTTPS pages.
- Proper HTTPS and TLS configuration is a central part of backend security and should be treated as a non-negotiable requirement for real-world systems.
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!