2.5. Ports
Table of Contents
Understanding Ports
When your browser talks to a server on the Internet, it is not enough to know which computer to talk to. You also need to know which application on that computer should receive the data. This is what ports are for.
This chapter explains ports from a backend developer perspective, with many practical examples you will see in web development.
What Is a Port?
Every machine on a network is identified by an IP address. But a machine almost always runs many networked programs at the same time. For example, on one server you might have:
- A web server for your website
- A database server
- An SSH server for remote login
- A Redis server for caching
- A mail server
All of these need to receive and send data over the network.
A port is a number that identifies a specific networked application (or service) on a machine.
You can think of it like this:
- IP address: the building address
- Port: the apartment number inside that building
To talk to a specific service, you need both:
- IP address, for example
203.0.113.10 - Port number, for example
5432
Together they give you a complete destination like:
203.0.113.10:5432
This says: "Connect to the machine at IP 203.0.113.10, application listening on port 5432."
Port Numbers and Their Ranges
Ports are just integers between 0 and 65535.
The range is:
$$ 0 \leq \text{port} \leq 65535 $$
This is because ports are stored as 16-bit unsigned numbers, and $2^{16} = 65536$ possible values, from 0 to 65535.
Rule: Valid TCP or UDP port numbers are from 0 to 65535. Values outside this range are invalid.
Port numbers are divided into three main ranges:
| Range | Name | Typical Use |
|---|---|---|
| 0 to 1023 | Well-known ports | Standard services like HTTP, HTTPS, SSH, FTP, DNS, etc. |
| 1024 to 49151 | Registered ports | Services registered by companies or projects |
| 49152 to 65535 | Dynamic / private | Temporary ports chosen by clients (ephemeral ports) |
As a backend developer, you will most often care about:
- Some well-known ports for standard protocols
- A few custom ports for your own development servers
Common Ports Backend Developers Should Know
Here are some of the ports you will see all the time.
Web and API related
| Port | Protocol / Use | Example |
|---|---|---|
| 80 | HTTP | http://example.com defaults to port 80 |
| 443 | HTTPS | https://example.com defaults to port 443 |
| 8080 | Alternative HTTP port | Local dev servers, proxies, test servers |
| 3000 | Common dev port | Node.js, frontend dev servers, some APIs |
| 8000 | Common dev port | Django, FastAPI, local API servers |
| 8001 | Alt. dev / admin port | Admin interfaces, second service instance |
Database related
| Port | Service (often default) |
|---|---|
| 5432 | PostgreSQL |
| 3306 | MySQL / MariaDB |
| 6379 | Redis |
| 27017 | MongoDB |
System and remote access
| Port | Service |
|---|---|
| 22 | SSH |
| 25 | SMTP (sending email) |
| 53 | DNS |
You do not have to memorize all ports, but you should quickly recognize:
- 80 and 443, for HTTP and HTTPS in production
- 5432, for PostgreSQL
- 6379, for Redis
- 22, for SSH
How Ports Work with IP and Protocol
A full network address for a service is actually a combination of:
- Protocol, for example TCP or UDP
- IP address
- Port number
So a connection is identified by:
$$ \text{Protocol} + \text{IP} + \text{Port} $$
As a result, these are all different "endpoints":
TCP 203.0.113.10:5432UDP 203.0.113.10:5432TCP 203.0.113.10:80TCP 198.51.100.7:80
Even if the port numbers match, different protocols or IPs give you different endpoints.
For web backends, you will almost always work with TCP ports. UDP is used in other contexts, such as DNS or streaming.
Important: When people say "port 80" in web development, they almost always mean TCP port 80.
Listening Ports and Active Connections
On a machine, there are two important concepts:
- Listening port
- A server program calls a system function that says: "I want to listen on port X."
- Example: Nginx listens on port 80, PostgreSQL listens on 5432.
- Active connection
- When a client connects, the operating system creates a connection between:
- Client IP + client port
- Server IP + server port
So for one connection you can think of this 4-part combination:
- Client IP
- Client port
- Server IP
- Server port
This combination is often called a "4-tuple."
Clients usually use ephemeral ports (high ports) chosen automatically by the OS.
Example:
- Client:
198.51.100.10:51123 - Server:
203.0.113.10:443
Your browser might be using port 51123 on your machine to connect to port 443 on the server. If you opened another tab to the same site, your browser might open a second connection like:
198.51.100.10:51124to203.0.113.10:443
The server still listens on 443, but there are multiple connections to it from different client ports.
Ports in URLs
When you type a URL in your browser, you often do not see the port. The browser uses default ports based on the scheme:
http://example.commeans HTTP over port 80https://example.commeans HTTPS over port 443
You only see a port in the URL if it is not the default:
http://localhost:8000uses HTTP on port 8000https://api.example.com:8443/v1/usersuses HTTPS on port 8443
Example comparisons:
| URL | Scheme | Host | Port used |
|---|---|---|---|
http://example.com | http | example.com | 80 |
https://example.com | https | example.com | 443 |
http://localhost:3000 | http | localhost | 3000 |
https://api.example.com:8443 | https | api.example.com | 8443 |
As a backend developer, in development you will very often specify ports explicitly in URLs, for example:
- Frontend dev server:
http://localhost:3000 - API dev server:
http://localhost:8000 - Admin dev panel:
http://localhost:8001
Localhost and Common Development Ports
When you run services on your own machine, you almost always connect to localhost with a port:
localhostusually refers to IP127.0.0.1(IPv4) or::1(IPv6).
Examples in backend development:
- Run a FastAPI app: server listens on
127.0.0.1:8000 - Run PostgreSQL locally: listens on
127.0.0.1:5432 - Run Redis locally: listens on
127.0.0.1:6379
Example workflow:
- Start a FastAPI app:
uvicorn main:app --reload --port 8000This command tells Uvicorn to listen on port 8000.
- Now you can open:
http://localhost:8000/in your browser- Or call it from another script:
import requests
response = requests.get("http://localhost:8000/health")
print(response.status_code, response.text)
If you change --port 8000 to --port 5000, then you must also change the URLs you use to http://localhost:5000.
What Happens If a Port Is Already in Use?
Only one process on a machine can listen on a specific port for a specific protocol and IP combination.
If you try to start a second server on the same port, you will usually get an error, for example in Python:
OSError: [Errno 98] Address already in useTypical situations:
- You already have a server running on port 8000.
- You try to run another development server on the same port.
- The OS refuses the second one.
Solutions:
- Stop the existing server.
- Or use a different port, for example 8001 instead of 8000.
As a backend developer, you will often change ports when:
- Running multiple apps locally at the same time.
- Running multiple versions of the same app, for example production and staging.
Ports and Firewalls
A firewall is a system that can allow or block network traffic based on rules. One of the most common things a firewall checks is the port number.
For example, on a production server you might configure:
- Allow incoming TCP connections on ports:
- 22 (SSH)
- 80 (HTTP)
- 443 (HTTPS)
- Block all other incoming ports
This means:
- If your API tries to listen on port 8000 and the firewall blocks it, clients on the Internet will not be able to connect, even if the server is running.
- Locally, on your machine, you can still access
http://localhost:8000because the firewall usually does not block loopback (localhost) traffic by default.
In cloud providers like AWS, DigitalOcean, GCP, you will see firewall-like settings called "security groups" or "firewalls" that typically specify allowed port ranges.
Ports on the Server vs Ports on the Client
When a client connects to a server, both sides use ports, but for different purposes.
- Server port
- Fixed, known and usually standard (like 80, 443, 5432).
- The server listens on this port and waits for connections.
- Client port
- Chosen automatically from the ephemeral port range.
- Only used for that one connection.
- The client usually does not care about the exact number.
For example, when your browser connects to a website:
- Server is listening on
203.0.113.10:443 - Your machine might use
192.0.2.20:51234as client port.
If you click another link:
- Browser might open another connection:
192.0.2.20:51235to203.0.113.10:443
You usually only configure the server side ports. The client side ports are handled by the operating system.
Multiple Services on One Server With Different Ports
One physical or virtual machine can host many services at once by using different ports.
Example:
| Service | Port | URL or Address |
|---|---|---|
| Main website | 80 | http://example.com |
| Secure website | 443 | https://example.com |
| Admin API | 8443 | https://example.com:8443 |
| PostgreSQL DB | 5432 | postgres://db.example.com:5432/... |
| Redis cache | 6379 | Connected to from app code, not browser |
Clients choose which service to talk to by picking the right port.
In many real deployments, you might hide some ports behind a reverse proxy so that external clients only see port 80 and 443, while your backend services talk to each other on internal ports.
Ports and Docker (Briefly)
You will learn Docker in detail later, but ports are important there too.
When you run a Docker container, it can expose a port inside the container. To reach it from your host machine, you map a host port to a container port.
Example:
docker run -p 8000:80 my-web-appThis means:
- Container listens on its internal port 80.
- Docker maps host port 8000 to container port 80.
- You can now open
http://localhost:8000, which forwards to port 80 inside the container.
You will do this often when running databases, Redis, or API servers in containers.
Practical Exercises You Can Try
You can try these on a Linux or macOS terminal. On Windows, use PowerShell with appropriate equivalents.
See which ports are listening
On Linux or macOS:
sudo lsof -i -P -n | grep LISTENYou will see output like:
nginx 1234 root 6u IPv4 12345 0t0 TCP *:80 (LISTEN)
postgres 5678 postgres 7u IPv4 23456 0t0 TCP 127.0.0.1:5432 (LISTEN)This tells you which applications are listening on which ports.
Run a simple Python HTTP server on a custom port
In a directory with some files, run:
python -m http.server 9000Now open:
http://localhost:9000/
If you run a second one on a different port:
python -m http.server 9001You can now access:
http://localhost:9000/http://localhost:9001/
Same program, same machine, different ports, so they can coexist.
Summary
- A port is a number that identifies a specific networked service on a machine.
- Valid ports are from 0 to 65535.
- Common web ports:
- 80 for HTTP
- 443 for HTTPS
- Many developer tools use ports like 3000, 8000, 8080 for local development.
- A connection is defined by protocol, IP addresses, and ports on both sides.
- Only one process can listen on a given IP + protocol + port combination.
- Firewalls often control access based on ports.
- In URLs, ports are usually hidden when you use the default (80 for HTTP, 443 for HTTPS), and shown explicitly when you use a custom port.
Understanding ports is essential when you configure servers, connect to databases, run services in Docker, or debug network connectivity issues in backend development.
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!