2.7. HTTP and HTTPS
Table of Contents
Why HTTP and HTTPS Matter for Backend Developers
When you build a backend, almost every client talks to your server using HTTP or HTTPS. Understanding them is critical, because:
- Every API request and response uses HTTP.
- Security on the web is mostly about using HTTPS correctly.
- Tools like browsers, curl, Postman, and proxies all speak HTTP.
This chapter focuses on what is specific to HTTP and HTTPS: how they look on the wire, how they differ, and what they mean for you as a backend developer.
What Is HTTP?
HTTP stands for HyperText Transfer Protocol. It is an application-level protocol that defines how clients and servers communicate text-based messages over the network.
A simple description:
- HTTP is a set of rules for:
- how a request is formatted,
- how a response is formatted,
- what each part means.
- HTTP itself does not care how data moves across the wire. Lower levels like TCP/IP handle that.
You will see HTTP in:
- Web pages (browser to web server).
- REST APIs (client apps to backend).
- Mobile apps (phone apps to your backend).
- CLI tools (curl, httpie) when they call APIs.
HTTP is stateless: the server does not remember previous requests automatically. Each request is independent. Sessions and cookies (covered later in the course) are built on top of HTTP to simulate “remembering” users.
Versions of HTTP
There are several versions of HTTP in common use:
| Version | Main idea | Typical use today |
|---|---|---|
| HTTP/1.0 | Simple, one request per connection | Mostly historical, rarely used explicitly |
| HTTP/1.1 | Persistent connections, more headers | Still extremely common in many backends |
| HTTP/2 | Multiplexing, header compression, binary | Widely used via browsers and CDNs |
| HTTP/3 | Uses QUIC over UDP, better performance on bad networks | Growing adoption, modern browsers |
As a beginner, you mostly need to understand the concepts of HTTP and the message format. HTTP/1.1 is the easiest to read and reason about as text. HTTP/2 and HTTP/3 are more efficient, but high-level concepts like methods, URLs, headers, and status codes remain the same.
HTTP Request and Response Structure (High Level)
The details of the request/response cycle will be explained in a dedicated chapter, but here is a short look at how HTTP uses plain text messages.
An HTTP request consists of:
- A request line
Example:
GET /products?limit=10 HTTP/1.1 - Headers (zero or more)
Example:
Host: example.com
User-Agent: Mozilla/5.0
Accept: application/json - A blank line
- An optional body (for example for POST or PUT)
Example:
{ "name": "New product" }
An HTTP response consists of:
- A status line
Example:
HTTP/1.1 200 OK - Headers
Example:
Content-Type: application/json
Content-Length: 27 - A blank line
- An optional body
Example:
{ "status": "success" }
You will work with all of these in detail in later chapters: HTTP Requests, HTTP Responses, HTTP Methods, HTTP Status Codes, and HTTP Headers.
What Is HTTPS?
HTTPS is HTTP over TLS. It is the same protocol (same methods, URLs, headers, status codes), but the data is encrypted and authenticated.
- HTTP: data is sent in plain text over TCP.
- HTTPS: HTTP data is wrapped inside TLS, which provides:
- Encryption,
- Integrity (data is not changed in transit),
- Authentication (server identity, via certificates).
The S in HTTPS stands for Secure.
From your point of view as a backend developer:
- Your application still works with regular HTTP constructs.
- The web server (for example Nginx, a cloud load balancer, or a reverse proxy) handles TLS encryption and decryption.
- Inside your code, you usually see “plain” HTTP requests, even when clients connect via HTTPS.
Important rule: Always use HTTPS in production.
Sending passwords, tokens, or any sensitive data over plain HTTP is insecure and must be avoided.
Plain HTTP vs HTTPS: What Changes?
URL Scheme
The URL scheme tells the client whether to use HTTP or HTTPS:
| Scheme | Example URL | Default port |
|---|---|---|
http | http://example.com/api/users | 80 |
https | https://example.com/api/users | 443 |
When you open a site with https:// the browser:
- Initiates a TCP connection to port 443.
- Performs a TLS handshake.
- Then sends HTTP data inside the encrypted TLS stream.
With http:// it uses port 80 and sends HTTP in plain text without TLS.
Ports
- HTTP default port: 80
- HTTPS default port: 443
You can change ports:
http://localhost:8000/https://api.example.com:8443/
In practice, production sites usually stick to the defaults.
Visibility of Data
With HTTP:
- Anyone who can see the network traffic (for example on public Wi-Fi, some ISPs, or compromised routers) can read:
- URLs and query strings,
- headers,
- cookies,
- body content including passwords or tokens.
With HTTPS:
- The data is encrypted in transit.
- Observers can see that you connect to a host (like
example.com), but not the exact path, the request body, or headers content (with some minor exceptions such as SNI revealing hostnames).
What TLS Adds on Top of HTTP
HTTPS uses TLS (Transport Layer Security). You do not need the full cryptography details now, but you should know what benefits it provides.
TLS provides three main properties:
1. Encryption
Data between client and server is unreadable to anyone else.
Example:
- With HTTP:
- Your login POST body might look like:
POST /login HTTP/1.1
Host: example.com
Content-Type: application/json
{ "email": "user@example.com", "password": "mypassword123" }A network sniffer can read this directly.
- With HTTPS:
- The same HTTP text is wrapped inside TLS, and a sniffer sees only encrypted bytes.
2. Integrity
TLS protects against modifications in transit.
- If an attacker tries to change the response body (for example altering JSON data), TLS will detect that the data has been tampered with.
- TCP ensures packets arrive and reorders them, but does not detect malicious changes. TLS adds cryptographic integrity checks.
3. Authentication (Server Identity)
TLS uses certificates to prove the identity of the server.
When you see a lock icon in the browser:
- The browser has verified that the server presented a certificate for a domain like
api.example.com. - The certificate is signed by a trusted Certificate Authority (CA).
- If the certificate is invalid or self-signed, the browser shows a warning.
As a backend developer, you must ensure:
- Your production site uses a valid certificate.
- It is configured correctly on the web server or load balancer.
The Basic HTTPS Connection Flow
At a high level, this is what happens when a client uses HTTPS:
- Client connects to
example.com:443using TCP. - Client and server perform a TLS handshake:
- Negotiate cryptographic algorithms.
- Exchange keys.
- Validate the server certificate.
- Once the TLS handshake succeeds, a secure channel is established.
- Client sends HTTP requests inside this secure channel.
- Server sends HTTP responses back through the same secure channel.
The important part: your API code sees regular HTTP requests after decryption. Most of the TLS complexity is handled by web servers and libraries.
Example: HTTP vs HTTPS in Practice
Example 1: Simple GET for a public API
HTTP (insecure):
GET /api/products HTTP/1.1
Host: api.example.com
Accept: application/jsonHTTPS (secure):
- On the wire, the raw text above is encrypted.
- Inside your backend framework, your handler receives a normal HTTP request: method, path, headers, etc.
Example 2: Login Request
HTTP:
POST /login HTTP/1.1
Host: example.com
Content-Type: application/json
{ "email": "user@example.com", "password": "SuperSecret!" }With plain HTTP:
- Anyone on the same network can read the password.
- Cookies or tokens in headers are exposed.
With HTTPS:
- Same HTTP structure, but travels in an encrypted tunnel.
- Attackers cannot read the email or password.
This is why login forms and APIs must use HTTPS.
Why Browsers Push HTTPS
Modern browsers strongly favor HTTPS:
- The lock icon or similar indication shows a secure connection.
- Many browser features are only available on HTTPS origins, for example:
- Service workers,
- Push notifications,
- Some advanced APIs.
- Browsers often mark HTTP pages as “Not Secure” especially if they contain form fields.
As a backend developer:
- Plan all production endpoints to be served via HTTPS.
- Redirect all HTTP traffic to HTTPS wherever possible, for example using an HTTP 301 “Moved Permanently” response.
Example redirect:
HTTP/1.1 301 Moved Permanently
Location: https://example.com/loginHTTP vs HTTPS: Summary Table
| Aspect | HTTP | HTTPS |
|---|---|---|
| Full name | HyperText Transfer Protocol | HTTP over TLS (Secure HTTP) |
| Encryption | No, plain text | Yes, contents are encrypted |
| Default port | 80 | 443 |
| Security | Vulnerable to snooping and tampering | Protects confidentiality and integrity |
| Certificates | Not used | Uses TLS certificates issued by CAs |
| Browser status | Often “Not secure” for forms or logins | Lock icon, considered secure if correctly set up |
Key statement:
Use HTTP for local development only, and HTTPS for any real users or sensitive data in production.
How This Affects Backend Development
You will usually see HTTPS in these contexts:
- Local development
- Often use HTTP, for example:
http://localhost:8000. - Less overhead, no need to manage certificates.
- Traffic stays on your machine, so encryption is less critical.
- Staging and production
- Must use HTTPS for real users and real data.
- Typically configured via:
- Cloud provider load balancers (AWS ALB, GCP, etc.),
- Reverse proxies (Nginx, Traefik),
- Services like Cloudflare.
- You might use services like Let’s Encrypt for free certificates.
- Internal microservices
- Sometimes use HTTP inside a private network, and HTTPS only at the public edge.
- Sometimes use HTTPS between internal services as well, depending on security requirements.
- APIs and mobile apps
- Mobile apps or SPA frontends call your backend using HTTPS.
- You must provide HTTPS endpoints so clients can trust your server and protect user data.
Recognizing HTTP / HTTPS in Tools
Browser Developer Tools
- In the Network tab, you will see
https://for secure requests. - Status column often shows a lock or details about the connection.
- You can inspect headers and bodies, the browser decrypts them for you.
curl
Using HTTP:
curl http://example.com/api/usersUsing HTTPS:
curl https://example.com/api/usersAdding details:
curl -v https://example.com/api/users
The -v flag shows TLS handshake steps and certificate information.
Postman / API clients
- You specify the full URL, for example
https://api.example.com/v1/users. - The client handles HTTPS automatically, including certificate validation.
- If the certificate is self-signed (common in development), clients might show warnings or require extra configuration.
Common Pitfalls for Beginners
Confusing HTTP with HTTPS
Remember:
- HTTP is the protocol.
- HTTPS is HTTP + TLS.
Your application logic (routes, controllers, handlers) usually works the same. The difference is at the network and server configuration level.
Sending Sensitive Data Over HTTP
Never send:
- Passwords,
- Session cookies,
- Access tokens,
- Personal user data
over plain HTTP in real environments. Use HTTPS.
Incorrect Redirects
Common pattern:
- Client visits
http://example.com. - Server responds with a redirect to
https://example.com.
Ensure:
- You redirect with status 301 or 302.
- You do not accidentally redirect in a loop (for example, redirecting HTTPS to HTTP then back).
Mixed Content
If your frontend is loaded over HTTPS, all its resources (APIs, images, scripts) should also be HTTPS.
If you try to call http:// API endpoints from an https:// page, browsers may block the request as “mixed content”.
Looking Ahead
In later chapters, you will dive into:
- HTTP Requests
Detailed structure of request lines, headers, and bodies. - HTTP Responses
How to construct correct responses. - HTTP Methods
GET, POST, PUT, DELETE, etc, and how they are used in APIs. - HTTP Status Codes
200, 201, 400, 404, 500, and others. - HTTP Headers
Content-Type, Authorization, Cookie, CORS-related headers, and more.
For all of these topics, the concepts are the same whether you use HTTP or HTTPS. HTTPS simply wraps all this communication in a secure envelope.
Quick Recap
- HTTP is the text-based protocol for communication between clients and servers.
- HTTPS is HTTP secured by TLS, which adds:
- Encryption,
- Integrity,
- Server authentication via certificates.
- Use HTTP locally for learning and small experiments, but always use HTTPS in production.
- Your backend code mostly deals with HTTP concepts, while HTTPS configuration is handled by web servers, infrastructure, or frameworks.
Understanding this foundation will make it easier to reason about APIs, security, and deployment as you move through the rest of the course.
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!