2.15. What Happens When You Enter a URL?
Table of Contents
Step 1: You Type a URL
When you type a URL like:
https://www.example.com/products?category=booksyour browser first needs to understand and parse it.
A URL usually has these parts:
| Part | Example | Meaning |
|---|---|---|
| Scheme | https | Protocol to use, usually HTTP or HTTPS |
| Hostname | www.example.com | Domain name of the server |
| Port | :443 (hidden) | Network port, defaults depend on scheme |
| Path | /products | Which resource on the server |
| Query string | ?category=books | Extra parameters |
| Fragment | #section-1 | Page position, handled only by browser |
Your browser splits this into pieces so it knows:
- Which protocol to use (HTTP or HTTPS).
- Which server to contact.
- Which port to connect to.
- Which resource to request from that server.
Important: The scheme (http/https) decides:
- Which port is used by default (80 or 443).
- Whether the connection is encrypted or not.
For the rest of this chapter, assume you enter https://www.example.com/.
Step 2: Browser Checks Cache and Hosts
Before talking to other computers, the browser checks what it already knows.
Browser cache for the IP
The browser first needs the IP address of www.example.com. To avoid asking every time, it checks:
- Its own in-memory DNS cache.
- The operating system’s DNS cache.
If it finds a cached IP address, it can skip a lot of work.
Example:
- Yesterday you visited
www.example.com. - The DNS answer said: "You can cache this IP for 1 hour" (TTL).
- If 30 minutes have passed, the browser can reuse that IP.
hosts file
If the IP is not cached, the OS may check the local hosts file:
- On Linux / macOS:
/etc/hosts - On Windows:
C:\Windows\System32\drivers\etc\hosts
Example hosts entry:
127.0.0.1 localhost
203.0.113.10 www.example.com
If such a line exists, www.example.com will resolve directly to 203.0.113.10, skipping external DNS.
As a backend developer, you sometimes use hosts entries to:
- Map custom domains to local development servers.
- Test staging environments.
Step 3: DNS Lookup
If the browser and OS do not know the IP address, they ask a DNS resolver.
Who is the DNS resolver?
Usually:
- Your router,
- Your ISP’s DNS server,
- Or a public DNS server like
8.8.8.8(Google) or1.1.1.1(Cloudflare).
Your computer sends a DNS query:
- "What is the IP for
www.example.com?"
The resolver then does the heavy work. It might already know the answer (cached). If not, it asks other DNS servers in this order:
- Root DNS servers
They do not knowwww.example.com, but they know where.comis managed. - TLD (Top Level Domain) server for
.com
It says, "The nameserver forexample.comisns1.something.com." - Authoritative DNS server for
example.com
This server knows the real IP forwww.example.com, for example93.184.216.34.
The resolver returns this IP to your computer and caches it for some time, defined by TTL (time to live).
Rule: DNS translates domain names to IP addresses.
Without DNS, you would have to use IP addresses like 93.184.216.34 instead of www.example.com.
Step 4: TCP Connection
Now the browser knows the IP, for example 93.184.216.34, and the scheme is https.
It must open a TCP connection:
- Destination IP:
93.184.216.34 - Destination port:
443(default for HTTPS) - Source IP and source port: chosen by your OS.
TCP handshake
Before sending HTTP data, TCP does a three-way handshake:
- Client sends
SYNto server. - Server responds
SYN-ACK. - Client responds
ACK.
After this, a reliable connection is established.
This handshake:
- Ensures both sides are ready.
- Sets up sequence numbers for ordered and reliable delivery.
As a backend developer, you usually do not implement TCP directly, but it is important to know that HTTP uses TCP on ports like 80 and 443.
Step 5: TLS Handshake (for HTTPS)
Because the URL starts with https, the browser wants an encrypted connection.
On top of TCP, it performs a TLS handshake.
In simple terms:
- Browser says "Hello", with:
- Supported TLS versions.
- Supported encryption algorithms (ciphers).
- A random number.
- Server responds with:
- Selected TLS version and cipher.
- Its TLS certificate, which contains its public key and its domain.
- Another random number.
- Browser verifies the certificate:
- Is it signed by a trusted Certificate Authority (CA)?
- Is it valid (not expired)?
- Does the domain in the certificate match
www.example.com? - If valid, the browser and server agree on a shared secret (session key), using the public key and some cryptography.
- From now on, data is encrypted before sending over TCP.
If certificate validation fails, the browser shows a warning like:
Your connection is not private.
Important: HTTPS = HTTP over TLS over TCP.
HTTP is the same protocol, but its content is encrypted and protected from eavesdropping and tampering.
Step 6: Browser Sends an HTTP Request
Now the browser has:
- A TCP connection.
- A secure TLS channel (for HTTPS).
- The URL and its parts.
It can send a HTTP request.
Example request for https://www.example.com/:
GET / HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Cookie: session_id=abc123Key parts:
- Request line:
GET / HTTP/1.1 - Method:
GET - Path:
/ - Protocol version:
HTTP/1.1 - Headers:
Host: Which domain the request is for. Required in HTTP/1.1.User-Agent: Information about browser and OS.Accept: What types of data the client can handle.Cookie: Previously set cookies for this domain.Connection: keep-alive: Suggests to keep TCP open for more requests.
For a GET request to a typical web page, there is no request body.
Step 7: Server Receives the Request
Somewhere on the internet, at IP 93.184.216.34 and port 443, there is a server.
This server usually has:
- A reverse proxy or web server (like Nginx, Apache, or a cloud load balancer).
- An application server (like Uvicorn, Gunicorn, Node.js server, etc).
- Your backend application code.
A simplified flow:
- The TCP and TLS parts are handled by the operating system and the web server / proxy.
- The web server reads the HTTP request.
- It decides which application should handle this request.
- It passes the request to the application server and then to your backend application.
For example, Nginx configuration might say:
location / {
proxy_pass http://127.0.0.1:8000;
}
So Nginx forwards the HTTP request to your backend running on port 8000.
Step 8: Backend Application Processes the Request
Your backend application now has access to:
- HTTP method (
GET) - Path (
/) - Query parameters (none in this example)
- Headers (like
Cookie,User-Agent) - Maybe a request body (for POST, PUT, etc)
The backend runs through several steps.
8.1 Routing
The application checks which route matches the request.
Example in FastAPI:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, world!"}
@app.get("/products")
def list_products():
return [{"id": 1, "name": "Book"}]
When it sees GET /, it calls read_root.
If you had requested GET /products, it would call list_products.
8.2 Middleware and authentication
Before hitting your route handler, the request might go through:
- Logging middleware.
- Authentication middleware that checks a session or token.
- CORS middlewares.
- Rate limiting.
Example logic:
- Read
Cookie: session_id=abc123. - Look up user session in Redis or database.
- Attach user info to the request, such as
user_id=42.
8.3 Business logic
Your route handler performs the business logic:
- Read from a database.
- Call other services or APIs.
- Apply application rules.
Example (pseudo code):
def list_products():
# Query database
products = db.query("SELECT id, name, price FROM products LIMIT 20")
# Return them as a JSON-compatible object
return {"items": products}8.4 Creating the HTTP response
The backend then builds a response:
- Status code, like
200 OK. - Headers, like
Content-Type,Set-Cookie. - Body, which can be HTML, JSON, images, etc.
Example HTTP response for an HTML page:
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 1256
Set-Cookie: session_id=abc123; HttpOnly; Secure; Path=/
Cache-Control: max-age=600
<!DOCTYPE html>
<html>
<head>
<title>Example</title>
</head>
<body>
<h1>Hello from example.com</h1>
</body>
</html>The web server sends this back over the TLS and TCP connection to your browser.
Step 9: Browser Receives the Response
The browser now has the HTTP response. It does several things.
9.1 Check the status code
Based on the status code, the browser decides what to do:
200 OK
Use the body as the main content.301or302(redirect)
Look at headerLocation, and automatically make a new request to that URL.404 Not Found
Show "Not found" page.500 Internal Server Error
Show "Server error" page.
9.2 Parse headers
The browser uses headers to adjust behavior:
Content-Type: text/html: Treat body as HTML.Content-Type: application/json: It might show JSON or give it to JavaScript.Set-Cookie: Store cookies for future requests.Cache-Control: Decide how long to cache this response.
Example Set-Cookie:
Set-Cookie: session_id=abc123; HttpOnly; Secure; Path=/; Max-Age=3600
The browser stores session_id=abc123 and will send it with every future request to this domain, unless it expires or is deleted.
Step 10: Browser Renders the Page
If the response is HTML, the browser starts rendering.
10.1 Parse HTML
The browser:
- Parses HTML into a DOM tree (Document Object Model).
- Reads
<head>and<body>.
Example HTML:
<!DOCTYPE html>
<html>
<head>
<title>Example</title>
<link rel="stylesheet" href="/styles.css">
<script src="/app.js"></script>
</head>
<body>
<h1>Hello</h1>
<img src="/logo.png" alt="Logo">
</body>
</html>From this, the browser finds subresources:
- CSS file
/styles.css. - JavaScript file
/app.js. - Image
/logo.png.
10.2 Make additional HTTP requests
For each external resource, the browser makes more HTTP requests to the same server (unless full URLs point elsewhere).
Example requests:
GET /styles.css HTTP/1.1
Host: www.example.com
...
GET /app.js HTTP/1.1
Host: www.example.com
...
GET /logo.png HTTP/1.1
Host: www.example.com
...These go through exactly the same network steps:
- Possibly reuse the same TCP and TLS connections with
keep-alive. - Go through routing on the server.
- Server returns CSS, JS, images, etc.
Your backend may serve these:
- Directly from the application.
- Via a web server like Nginx as static files.
- From a CDN (Content Delivery Network).
10.3 Apply CSS, run JavaScript
The browser:
- Applies the CSS to style the page.
- Runs JavaScript, which can:
- Modify the DOM (change the page).
- Make more network requests (AJAX / fetch).
- Interact with the user.
As a backend developer, you mainly care about:
- The network requests the JavaScript sends.
- The APIs it calls.
- How your backend responds.
Step 11: Further Requests and Interactions
Once the initial page is loaded, the user might:
- Click on a link.
- Submit a form.
- Trigger JavaScript actions.
Each of these can cause new HTTP requests.
Examples:
- User clicks link
<a href="/products">Products</a>
Browser requests:
GET /products HTTP/1.1
Host: www.example.com
Cookie: session_id=abc123- User submits a login form:
Form:
<form method="POST" action="/login">
<input name="username">
<input name="password" type="password">
<button type="submit">Login</button>
</form>Browser sends:
POST /login HTTP/1.1
Host: www.example.com
Content-Type: application/x-www-form-urlencoded
Content-Length: ...
username=alice&password=secret123- JavaScript fetch:
fetch("/api/products")
.then(response => response.json())
.then(data => console.log(data));Browser sends:
GET /api/products HTTP/1.1
Host: www.example.com
Accept: application/jsonEach request repeats the same high-level sequence:
- Browser prepares HTTP request.
- Uses existing connection or opens a new one.
- Optional DNS lookup if domain is different.
- Sends request.
- Backend processes it and returns a response.
- Browser updates the page or internal state.
Step 12: Connection Reuse and Closing
TCP connections are not always closed immediately.
- With
Connection: keep-alive, multiple HTTP requests and responses can use the same TCP connection. - This avoids repeating the TCP and TLS handshakes for every small resource.
After some time of inactivity, either the client or the server closes the connection with a TCP FIN message.
New requests later may open new connections.
Putting It All Together
Let us summarize the main steps when you enter a URL like https://www.example.com/:
- Parse URL into scheme, host, port, path, query.
- Check cache and hosts for an existing IP.
- Do DNS lookup if needed, to find the IP of
www.example.com. - Open TCP connection to IP on port 443.
- Perform TLS handshake to secure the connection (HTTPS).
- Send HTTP request, for example
GET / HTTP/1.1. - Server receives and forwards request to backend application.
- Backend routes the request, runs middleware, business logic, database queries.
- Backend builds HTTP response with status, headers, and body.
- Browser receives response, stores cookies, applies caching rules.
- Browser parses HTML, makes more requests for CSS, JS, images.
- Browser renders page and runs JavaScript.
- Further user actions cause more HTTP requests and responses.
As a backend developer, you mostly work on steps 7 to 9, but understanding the whole journey helps you:
- Debug issues like "site does not load".
- Interpret browser dev tools.
- Configure things like HTTPS, domains, and caching correctly.
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!