22.7. HTTPS
Table of Contents
Why HTTPS Matters
HTTPS is HTTP over an encrypted connection. It protects the data that travels between a client and your backend server.
With plain HTTP, anyone on the network can:
- Read the traffic (passwords, tokens, personal data)
- Modify responses (inject malicious JavaScript, change API data)
- Pretend to be your server (phishing or man-in-the-middle)
HTTPS solves these problems by adding:
- Confidentiality: Data is encrypted, others cannot read it.
- Integrity: Data cannot be changed silently.
- Authentication: The client can verify it is talking to the real server.
Rule: Every production backend that handles user data must use HTTPS, never HTTP.
Today, browsers mark non-HTTPS sites as “Not secure”, and many features (like service workers) only work over HTTPS.
HTTP vs HTTPS
From a backend developer’s point of view, HTTP and HTTPS look very similar.
| Aspect | HTTP | HTTPS |
|---|---|---|
| Default port | 80 | 443 |
| URL scheme | http:// | https:// |
| Encryption | None | Uses TLS |
| Data visibility | Plain text | Encrypted (cannot be read by observers) |
| Certificate | Not required | Requires X.509 certificate |
| Browser indicator | No lock icon, “Not secure” | Lock icon, sometimes “Secure” |
| Performance | Slightly faster handshake only | Slight overhead, but usually negligible |
Your backend code (for example a FastAPI app) usually does not change. The main differences are:
- The server stack in front of your app (Nginx, Traefik, cloud load balancer) terminates TLS.
- The URLs you expose to users and clients use
https://.
TLS: The Protocol Behind HTTPS
HTTPS uses TLS (Transport Layer Security) to secure connections. You might still encounter the older name SSL, but SSL is deprecated. Modern HTTPS uses TLS 1.2 or TLS 1.3.
The core goals of TLS:
- Encrypt all data sent between client and server.
- Verify identity of the server using certificates.
- Detect tampering of traffic.
At a high level, a TLS connection has two phases:
- Handshake
Client and server: - Agree on a protocol version and cipher suite.
- Authenticate the server using its certificate.
- Securely establish shared secret keys.
- Secure data transfer
All HTTP data is sent encrypted using the keys from the handshake.
As a backend beginner, you do not need to know every cryptographic detail, but you should understand:
- TLS happens below HTTP in the network stack.
- Your application code usually just sees normal HTTP requests, once decrypted by the web server or reverse proxy.
How HTTPS Works Step by Step
Let us walk through what happens when a user opens https://api.example.com/users.
1. DNS and TCP Connection
- The browser resolves
api.example.comto an IP using DNS. - The browser opens a TCP connection to the server on port 443.
At this point, the connection is not yet encrypted.
2. TLS Handshake (Simplified)
- ClientHello
The client sends: - Supported TLS versions
- Supported cipher suites
- Random value
- ServerHello
The server replies with: - Chosen TLS version
- Chosen cipher suite
- Its own random value
- Server Certificate
The server sends its certificate, which contains: - The server’s public key
- The domain name it is valid for
- Information about the issuing Certificate Authority (CA)
- Validity period
- Certificate verification (client side)
The browser checks: - The certificate is not expired.
- The domain in the certificate matches the URL (for example
api.example.com). - The certificate is signed by a trusted CA.
If anything fails, the user sees a big warning.
- Key exchange
Client and server perform a key exchange algorithm (for example using elliptic curve Diffie-Hellman) to create a shared secret, even though they never send the secret directly. - Session keys
Both sides derive symmetric encryption keys from the shared secret. These keys are used to encrypt and decrypt HTTP data. - Finished messages
Each side sends an encrypted “Finished” message to confirm the handshake is done.
At the end of this process:
- Both client and server share secret keys.
- The client is confident about the server identity.
- All further HTTP messages are encrypted.
3. Encrypted HTTP Traffic
Once TLS is established, normal HTTP requests and responses flow inside the encrypted channel.
To your application framework (FastAPI, Django, etc.), it looks like a regular HTTP request. The web server or reverse proxy handles decryption.
Certificates and Certificate Authorities
TLS relies on certificates to prove identity. These are X.509 certificates in practice.
What Is an HTTPS Certificate?
A certificate is a digitally signed file that contains:
- The public key of the server.
- The domain name it is valid for (CN and/or Subject Alternative Name).
- The validity period (start and end dates).
- The certificate issuer (a CA).
- The certificate’s own serial number and metadata.
The server also has a private key associated with the certificate’s public key. The private key must remain secret.
Rule: Never commit private keys to Git or any code repository. Keep them secret and protected.
Certificate Authorities (CAs) and Trust
The browser must trust the certificate. It does this by:
- Keeping a built-in list of trusted root CAs.
- Verifying that:
- The certificate is signed, directly or indirectly, by one of those trusted CAs.
- The domain matches.
- The certificate is not expired or revoked.
This creates a chain of trust:
- Root CA certificate (trusted by OS / browser).
- Intermediate CA certificate.
- Your server certificate.
If any link is missing or invalid, the browser warns the user.
Types of Certificates
For a backend developer, the most important aspects are domain coverage and validation level.
By Domain Coverage
| Type | Description | Example |
|---|---|---|
| Single-domain | Valid for exactly one domain | api.example.com |
| Wildcard | Valid for a domain and all its first-level subdomains | *.example.com covers api.example.com, shop.example.com |
| Multi-domain (SAN) | Valid for several specific domains | api.example.com, admin.example.com |
For microservices, wildcard or multi-domain certificates are often used.
By Validation Level
| Type | Validation | Typical use |
|---|---|---|
| DV (Domain Validated) | Only checks domain ownership | Most APIs and websites, including Let’s Encrypt |
| OV (Organization Validated) | Verifies organization details | Business sites that want extra assurance |
| EV (Extended Validation) | Very strict verification, shows org name in some UIs | High profile banking or finance sites |
Modern practice: DV certificates are enough for almost all backends and public APIs.
Self-Signed vs CA-Signed Certificates
You can create certificates yourself or get them from a CA.
Self-Signed Certificates
A self-signed certificate is signed by its own private key. It is free and easy to generate, for example for testing.
Example (Linux, OpenSSL):
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem \
-days 365 -nodes -subj "/CN=localhost"Problems:
- Browsers do not trust it by default.
- Users will see scary warnings for your domain.
- Not suitable for public production services.
Self-signed certificates are useful for:
- Local development.
- Internal services where you can install your own CA in the trust store.
CA-Signed Certificates
Certificates from a trusted CA, such as Let’s Encrypt, are recognized by browsers.
Advantages:
- No browser warnings (if configured correctly).
- Automatically trusted across devices.
For public production APIs, you must use CA-signed certificates.
TLS Termination and Your Backend
In real deployments, your actual backend application (Uvicorn, Gunicorn, FastAPI app) usually does not handle TLS directly.
Instead, the setup looks like this:
Client (HTTPS)
|
v
Reverse Proxy (Nginx, Traefik, cloud load balancer)
- Terminates TLS
- Decrypts HTTPS to HTTP
|
v
Application Server (Uvicorn/Gunicorn, FastAPI)
- Receives plain HTTP on localhostThis is called TLS termination at the reverse proxy.
Why do this?
- Easier certificate management in one place.
- Your app code remains simple, only deals with HTTP.
- Reverse proxy can handle many concerns: load balancing, caching, compression, static files.
Rule: Expose only the HTTPS endpoint to the public internet. The internal HTTP between proxy and app should not be publicly reachable.
Common HTTPS Configurations (Conceptual)
You will see detailed Nginx, Traefik, and certificate setup in other chapters. Here is what you need to conceptually understand.
1. Redirect HTTP to HTTPS
Always redirect http:// traffic to https:// so users and clients use secure connections.
Typical behavior:
- Client requests
http://api.example.com/users. - Server responds with a
301or302redirect tohttps://api.example.com/users.
This ensures:
- No sensitive data is sent over HTTP.
- Search engines and bookmarks use the secure version.
2. HSTS (HTTP Strict Transport Security)
HSTS tells browsers to always use HTTPS for your domain.
The server sends a header like:
Strict-Transport-Security: max-age=31536000; includeSubDomains; preloadMeaning:
- For the next 1 year (
max-age=31536000seconds), use HTTPS only. - Apply this rule to all subdomains.
preloadrequests inclusion in browser preload lists.
Be careful: once enabled with a long max-age, you cannot easily go back to plain HTTP.
Security Benefits and Limitations of HTTPS
What HTTPS Protects Against
- Eavesdropping: Attackers cannot read the content of requests and responses.
- Data tampering: Attackers cannot modify traffic without detection.
- Simple impersonation: Attackers cannot easily pretend to be your server if certificates are correct.
What HTTPS Does Not Solve
HTTPS does not replace other security practices. It does not solve:
- Weak or reused passwords.
- SQL injection or XSS.
- Insecure password storage.
- Broken authentication logic.
- Bad access control.
Rule: HTTPS is necessary but not sufficient. You still must implement all other web security best practices.
Performance Considerations
TLS used to be considered “heavy” but modern hardware and protocols make HTTPS overhead small.
Key points:
- The handshake is the most expensive part. Once a connection is established, additional requests on the same connection are cheap.
- HTTP/2 and HTTP/3, which require or assume encryption, can be more efficient than HTTP/1.1.
- Caching and connection reuse (keep-alive) help reduce the cost.
For almost all backend applications, the benefits of HTTPS far outweigh the performance cost.
Practical Tips for Backend Beginners
As you start deploying backend services, keep these in mind:
- Use HTTPS everywhere in production
- APIs, admin panels, user-facing sites.
- Avoid mixing HTTP and HTTPS on the same app.
- Redirect HTTP to HTTPS
- Configure your reverse proxy or cloud load balancer.
- Test that
http://your-domainalways becomeshttps://your-domain. - Use Let’s Encrypt or another CA
- Automate certificate issue and renewal.
- Never let certificates expire unnoticed.
- Keep private keys secret
- Do not commit them to Git.
- Restrict filesystem permissions.
- Consider using secret management tools, covered in security chapters.
- Check your configuration
- Use tools like SSL Labs’ SSL Server Test to analyze your domain.
- Aim to disable old protocols (like TLS 1.0, 1.1) and unsafe ciphers.
- Understand termination
- Know which component in your stack terminates TLS.
- Forward client IPs and protocol info (for example with
X-Forwarded-For,X-Forwarded-Proto) so your app can log correctly.
Example: From HTTP to HTTPS in an API
Imagine you built a FastAPI application that runs on http://localhost:8000 in development.
For production:
- You deploy it behind Nginx.
- Nginx listens on port 443 with a valid certificate.
- Nginx forwards decrypted HTTP traffic to your app on
http://127.0.0.1:8000. - Nginx also listens on port 80 and redirects all HTTP traffic to HTTPS.
From the client’s point of view:
- They only see
https://api.example.com. - All communication is encrypted.
- Your app code did not need to change.
This separation lets you focus on application logic while still providing secure HTTPS to your users and API consumers.
By understanding HTTPS in this way, you will be ready to configure secure endpoints together with web servers and reverse proxies, and to recognize when your deployments are not properly protected.
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!