2.4. DNS
Table of Contents
Why DNS Exists
When you open a website, you type a name like example.com, not an IP address like 93.184.216.34. Computers on the internet, however, use IP addresses to talk to each other.
DNS, which stands for Domain Name System, is the system that translates human friendly domain names into machine friendly IP addresses. It is often called the "phonebook of the internet."
Without DNS, you would have to remember and type IP addresses for every site:
- Instead of
google.com, you would type something like142.250.185.78. - Instead of
wikipedia.org, you would type something like208.80.154.224.
For backend development, understanding DNS matters because it affects how your API is reached, how you point domains to your servers, and how production issues can be caused by misconfigured DNS records.
DNS exists to map names to IP addresses, so clients can reach servers using readable domain names.
Basic DNS Concepts
DNS is a distributed database spread across many servers worldwide. No single server knows everything, but together they provide the complete mapping of domain names to records.
Some key concepts:
Domain: A name like example.com that you can register and configure.
Subdomain: A name that is a part of a domain, like api.example.com or blog.example.com.
Hostname: Often used to mean a specific name that points to a server, typically a domain or subdomain like www.example.com or api.example.com.
Zone: A portion of the DNS namespace managed by a particular authority. When you manage DNS for example.com at a DNS provider, that DNS configuration is the example.com zone.
Record: An entry within a zone that maps a name to some data. For example, api.example.com to an IP address.
Most backend developers work directly with records, not the deeper implementation details of DNS servers.
How DNS Resolves a Domain
When you type https://api.example.com in your browser, the browser must translate api.example.com to an IP address before it can connect.
Here is a simplified sequence of what happens:
- Your application or browser checks its own cache. If it recently looked up
api.example.com, it might already know the IP and skip the rest. - If not cached locally, the request goes to a DNS resolver, usually operated by your ISP or a public DNS provider like Google DNS (
8.8.8.8) or Cloudflare (1.1.1.1). - The resolver checks its own cache. If not present, it performs a recursive lookup by asking other servers:
- A root DNS server, which tells it where to find the TLD (Top Level Domain) servers for
.com. - A
.comTLD server, which tells it which nameservers are authoritative forexample.com. - The authoritative nameserver for
example.com, which returns the final answer, for example the IP address ofapi.example.com. - The resolver returns the IP to your browser, and usually caches it for a certain time.
- Your browser connects to that IP address on the appropriate port, typically port 80 or 443 for web traffic.
From a backend developer’s perspective, the important parts are:
- There is caching at multiple layers, so DNS changes are not instant.
- A failure at the DNS resolver or authoritative server can make your service unreachable, even if your server is healthy.
Root, TLD, and Authoritative Servers
The DNS system is hierarchical.
At the top are root servers. They do not know every domain, but they know where to find the servers for top level domains such as .com, .org, .net, .io.
Below that are TLD servers. A .com TLD server knows which authoritative nameservers are responsible for domains like example.com, github.com, google.com.
Authoritative nameservers hold the final records for a domain. If you use a DNS provider such as Cloudflare, AWS Route 53, or your domain registrar’s DNS, their servers act as authoritative nameservers for your domain.
Example of the path for resolving api.example.com:
- Root server: "I do not know
api.example.com, but here are the nameservers for.com." .comTLD server: "I do not knowapi.example.com, butexample.comis managed by these authoritative nameservers:ns1.dns-provider.net,ns2.dns-provider.net."- Authoritative server: "For
api.example.com, the IP address is203.0.113.10."
Once that answer is obtained, it can be cached for some time.
DNS Records You Must Know
DNS records are typed entries in the DNS zone for a domain. Each type has a specific purpose. As a backend developer, you will regularly deal with at least A, AAAA, CNAME, and TXT records.
The most common DNS record types are:
| Record type | Purpose | Example use |
|---|---|---|
| A | Maps a name to an IPv4 address | api.example.com → 203.0.113.10 |
| AAAA | Maps a name to an IPv6 address | api.example.com → 2001:db8::1 |
| CNAME | Creates an alias from one name to another | www.example.com → example.com |
| MX | Specifies mail servers for a domain | For email delivery to user@example.com |
| TXT | Stores arbitrary text data | SPF records, domain verification, etc. |
| NS | Specifies authoritative nameservers for zone | example.com uses ns1.provider.com, ns2... |
| SRV | Specifies service discovery records | Some services use for locating specific ports |
| CAA | Restricts which CAs can issue certificates | Used for TLS certificate security |
The records you are most likely to configure when exposing a backend API are A, AAAA, CNAME, and sometimes TXT.
A and AAAA Records
An A record maps a name to an IPv4 address. For instance, suppose your API server is at IPv4 address 203.0.113.10. You might set up:
| Name | Type | Value |
|---|---|---|
api.example.com | A | 203.0.113.10 |
Now a DNS lookup for api.example.com will return that IPv4 address, and clients can connect.
An AAAA record is similar, but for IPv6 addresses. For example:
| Name | Type | Value |
|---|---|---|
api.example.com | AAAA | 2001:db8:abcd::10 |
You can have both A and AAAA records for the same hostname. Clients that support IPv6 might use the AAAA record, while others use the A record.
As a backend developer deploying APIs, you often receive a server IP address from your hosting provider or cloud platform, and then you create A and possibly AAAA records to point your domain to that IP.
An A record maps a hostname to an IPv4 address, and an AAAA record maps a hostname to an IPv6 address.
CNAME Records
A CNAME record creates an alias from one name to another canonical name. For example, suppose your main domain points to your server:
| Name | Type | Value |
|---|---|---|
example.com | A | 203.0.113.10 |
You can then create:
| Name | Type | Value |
|---|---|---|
www.example.com | CNAME | example.com |
Now both example.com and www.example.com will end up at the same IP address, because www.example.com resolves to example.com, and example.com resolves to 203.0.113.10.
Common use cases for CNAME records for backend work:
- Making
api.example.coman alias to a host provided by a cloud load balancer such aslb1234.somecloud.com. - Mapping multiple subdomains to a single canonical name, so you only change one place if the destination changes.
Example:
| Name | Type | Value |
|---|---|---|
api.example.com | CNAME | backend-1.hosting.com |
auth.example.com | CNAME | backend-1.hosting.com |
If the hosting provider changes the IP of backend-1.hosting.com, you do not need to modify your CNAME records. They continue to point to that name, which is updated by the provider.
There are practical rules:
- The canonical name in a CNAME must be another domain name, not an IP address.
- A name that has a CNAME record must not have other record types at the same name in the same zone, except for special cases. For example, you should not have both CNAME and A records for exactly the same name.
MX, TXT, and Other Records
While focusing on backend APIs, you still often encounter MX and TXT records, especially when you implement email verification or password reset features that rely on your domain’s email setup.
MX records:
- Indicate which mail servers receive email for your domain.
- For example,
example.commay have MX records pointing to provider mail servers likemx1.mailprovider.comandmx2.mailprovider.com.
TXT records:
- Store arbitrary text. They are heavily used for:
- SPF records that specify which servers may send email for your domain.
- DKIM and DMARC records for email security.
- Domain verification for third party services, for example to prove ownership of
example.comto an email sending service or cloud provider. - A TXT record might look like this:
- Name:
_acme-challenge.example.com - Type:
TXT - Value:
some-verification-token
As a backend engineer, when integrating with mail providers or cloud services, you will often be instructed to add specific TXT records to your DNS.
SRV and CAA records:
- SRV records specify service locations, including host and port for particular protocols. Some systems use them for auto discovery, but they are less common in basic web and API hosting.
- CAA records restrict which certificate authorities are allowed to issue TLS certificates for your domain. They are useful for improving security of HTTPS, which is covered elsewhere.
DNS Lookup Examples
You can inspect DNS records from the command line. This is very useful when debugging backend issues.
On Linux or macOS, you might use dig or nslookup. For example:
Using dig to resolve an A record:
dig api.example.com AYou might see a result that includes:
;; ANSWER SECTION:
api.example.com. 300 IN A 203.0.113.10
This shows that api.example.com has an A record pointing to 203.0.113.10 with a TTL of 300 seconds.
To see all records, you can use:
dig api.example.com ANYor for a specific type:
dig example.com MX
dig example.com TXTOn Windows, you can use:
nslookup api.example.comFor a TXT record:
nslookup -type=TXT example.comLearning to check DNS from the command line helps you understand if a problem is:
- Due to your DNS configuration.
- Due to caching and propagation delay.
- Or due to something else like server downtime or a firewall issue.
TTL and Caching
DNS responses are cached to reduce the load on DNS servers and speed up lookups. Each DNS record has a Time To Live, usually abbreviated as TTL, measured in seconds. The TTL tells resolvers how long they can cache the record before they must ask again.
For example:
| Name | Type | TTL | Value |
|---|---|---|---|
api.example.com | A | 300 | 203.0.113.10 |
This means that once a resolver looks up api.example.com, it can store the result for 300 seconds, which is 5 minutes. During that time, it will reuse the cached IP and will not ask the authoritative server again.
TTL controls how long DNS answers are cached. Lower TTL means faster updates but more DNS traffic. Higher TTL means slower updates but fewer DNS queries.
If you change a DNS record, users might still see the old IP until the cached TTL expires. That delay is often called DNS propagation.
Example strategy when you plan to move your API to a new server:
- A day before the migration, reduce the TTL of
api.example.comfrom something like 3600 seconds to 300 seconds. - Wait for at least the original TTL so caches holding the old long TTL expire.
- Perform the migration. Change the A record to the new IP.
- Because the TTL is now 300 seconds, most clients will see the new IP within a few minutes.
- After migration, you may increase the TTL again if you want fewer DNS queries.
DNS and Backend Deployments
When you deploy your backend in production, you almost always interact with DNS.
Typical flow when launching api.example.com:
- You register a domain, for example
example.com, at a domain registrar. - You choose or configure DNS hosting for that domain. This may be the registrar itself, or another provider such as Cloudflare or AWS Route 53.
- At your DNS provider, you create records:
- An A record for
example.comto point to your main web server. - An A record or CNAME record for
api.example.comto point to your API server or load balancer. - You configure your backend application server or reverse proxy to respond to
api.example.com. Browsers and clients can now reach your API athttps://api.example.com.
If you migrate to a different provider, you usually:
- Keep the same domain
api.example.com. - Update the DNS record to point to the new provider’s IP address or hostname.
- Wait for DNS propagation to take effect.
If something goes wrong and you see error messages like "Server not found" or "DNS_PROBE_FINISHED_NXDOMAIN", this can indicate:
- The domain name has no DNS record configured.
- The DNS record for that subdomain is misconfigured or missing.
- The nameservers for the domain are not set correctly at the registrar.
Knowing how DNS records are structured lets you diagnose these issues quickly.
DNS Tools for Developers
Backend developers typically use both command line tools and online tools to inspect DNS.
Command line tools:
digfor detailed queries and debugging.nslookupfor simple queries and quick checks.hostfor basic lookups.
Online tools:
- Web based DNS checkers that show A, AAAA, CNAME, MX, TXT, and NS records.
- Global propagation checkers that show what different resolvers around the world see, which is useful to see if a change has propagated.
Example: If you add an A record for api.example.com and it seems not to work for some users, a propagation checker can show if some regions still see the old IP or no record at all.
As you build and deploy backends, it is important to practice:
- Creating and editing DNS records for test domains.
- Using
digornslookupto verify that the DNS changes match what you intended. - Checking TTLs and understanding how long changes might take to reach users.
Over time, DNS becomes a routine part of your deployment and maintenance workflow.
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!