7.2. What Is REST?
Table of Contents
Understanding REST
REST is a way to design and build web APIs that is simple, predictable, and easy to use. You will use REST ideas all the time as a backend developer, especially when building HTTP APIs.
This chapter explains what REST is, what it is not, and the key ideas you need before you design any REST API.
REST as an Architectural Style
REST stands for Representational State Transfer. It is not a protocol and not a library. REST is an architectural style for designing networked applications, especially APIs over HTTP.
An architectural style is a set of rules and constraints that guide how you structure and connect different parts of a system. REST says:
- Use HTTP as it was designed.
- Model your data as resources.
- Manipulate resources using standard HTTP methods.
- Make your API stateless and cache friendly.
You can build a REST API in any language or framework, as long as you follow these ideas.
REST is an architectural style, not a standard or protocol.
If someone says "Our API is RESTful," they mean "We try to follow REST ideas."
REST and HTTP
REST works very naturally with HTTP, which you already saw in earlier chapters.
Key points about using HTTP in a RESTful way:
- URI identifies a resource
Example: GET /users/123identifies user with ID123GET /products/42identifies product with ID42- HTTP method describes what you want to do with that resource
Typical methods:GET,POST,PUT,PATCH,DELETE - HTTP status code describes the result of the operation
Examples:200 OK,201 Created,404 Not Found,400 Bad Request - HTTP headers and body carry metadata and data
Examples:Content-Type: application/jsonand JSON in the body.
REST does not change HTTP. It simply says: use HTTP as it was intended, instead of inventing your own "action" mechanisms.
Bad, non RESTful idea:
POST /doAction
{
"action": "createUser",
"data": { "name": "Alice" }
}Better, more RESTful approach:
POST /users
{
"name": "Alice"
}
Here the resource is /users and the HTTP method POST already means "create something."
The Core REST Constraints
REST is defined by a small set of constraints. If you respect them, your API is more likely to be simple, scalable, and cacheable.
The main REST constraints are:
- Client Server
- Stateless
- Cacheable
- Uniform Interface
- Layered System
- (Optional) Code on Demand
We will focus on the ones that matter most for web APIs you will build.
1. Client Server
The client and server are separate. They communicate over HTTP, but they do not need to know each other's internal details.
- The client does not care how the server stores data, which database it uses, or what programming language it is written in.
- The server does not care how the client shows data to the user, whether as a web page, mobile app, or CLI.
This separation:
- Makes it easier to change the frontend without changing the backend.
- Makes it easier to change the backend technology without changing clients, as long as the API stays the same.
Example:
- Today your frontend is a React web app.
- Tomorrow you add a mobile app that calls the same REST API.
- The backend does not change, only the clients.
2. Stateless
Stateless means that each request from a client to a server must contain all the information needed to understand and process the request. The server does not store client session data between requests.
In practice:
- The server does not remember "who you are" by default.
- The client includes everything the server needs in each request, for example:
- Authentication token in the
Authorizationheader - Parameters in the path or query string
- Request body with the necessary data
Non stateless approach:
- Client:
POST /loginwith credentials
Server: "OK, you are user 123" and stores session in memory. - Client:
GET /profilewithout any ID or token
Server: Uses in memory session to know that this is user 123.
More stateless approach:
- Client:
POST /loginwith credentials
Server: returns a token that represents the user. - Client:
GET /profilewith headerAuthorization: Bearer <token>
Server: Reads token, identifies user, and returns profile. No in memory session is required.
RESTful APIs are stateless. Every request must contain all information required to handle it.
Stateless design helps with:
- Scalability. Any server instance can handle any request, because it does not depend on local session memory.
- Reliability. If one server goes down, another can continue without losing user state.
Note: Many real systems still use sessions, but REST encourages you to minimize server side state.
3. Cacheable
REST encourages you to use caching to improve performance.
- Responses should say whether they are cacheable, and for how long, using HTTP headers.
- A cached response can be reused for later, identical requests.
Typical examples:
GET /products/42might be cacheable for 60 seconds, since product data does not change every millisecond.GET /weather?city=Londonmight be cacheable for 10 minutes.
Examples of HTTP headers that affect caching:
Cache-Control: max-age=60, public
ETag: "abc123"
Last-Modified: Tue, 27 Aug 2024 10:00:00 GMTIf you follow REST and use proper HTTP caching headers, you get better performance with less server load.
4. Uniform Interface
The uniform interface is the core idea of REST. It means:
- Use a single, consistent way to identify and interact with resources.
- Use HTTP methods consistently.
- Use standard status codes.
- Use consistent representations and links.
This has several sub-ideas.
Resource based
In REST you think in terms of resources, not actions.
A resource is anything that can be identified and manipulated. Examples:
- User
- Product
- Order
- Blog post
- Comment
Each resource has a URI:
/users/users/123/products/products/42/reviews
You focus on nouns, not verbs in the URL.
Not RESTful style:
POST /createUserPOST /deleteUserPOST /updateUser
More RESTful style:
POST /usersto createDELETE /users/123to deletePUT /users/123orPATCH /users/123to update
Manipulation of resources through representations
Clients do not work with the resource directly. They work with a representation of the resource, usually JSON.
For example, the resource might be "user 123 in the database," but the representation you send in the HTTP response is JSON:
{
"id": 123,
"name": "Alice",
"email": "alice@example.com"
}The client sends representations in requests to create or update resources.
Example:
PUT /users/123
Content-Type: application/json
{
"name": "Alice Johnson",
"email": "alice@example.com"
}The server updates the underlying resource using this representation.
Self descriptive messages
Each HTTP request and response should be self descriptive. That means you can understand it without extra hidden context.
- HTTP method shows the intent.
- URI shows the resource.
- Headers clarify metadata, such as content type or authentication.
- Body contains the data.
Example response:
HTTP/1.1 201 Created
Content-Type: application/json
Location: /users/123
{
"id": 123,
"name": "Alice",
"email": "alice@example.com"
}From this message, you can see:
- The operation succeeded and created something (
201 Created). - The new resource is at
/users/123(Location header). - The representation is JSON (Content-Type).
- The content of the resource is shown in the body.
HATEOAS (Hypermedia as the Engine of Application State)
This is the strictest part of REST and many practical APIs do not fully implement it.
HATEOAS means the API provides links inside responses to show what you can do next.
Example:
{
"id": 123,
"name": "Alice",
"email": "alice@example.com",
"_links": {
"self": { "href": "/users/123" },
"orders": { "href": "/users/123/orders" },
"update": { "href": "/users/123", "method": "PATCH" }
}
}The idea:
- The client does not need to hardcode paths for every action.
- The client can follow links provided by the server.
In real life, many APIs are called "RESTful" but ignore HATEOAS. That is common, and usually acceptable, but keep in mind that strict REST includes this concept.
5. Layered System
A REST API can use layers between the client and the actual server, such as:
- Load balancers
- Caches
- Reverse proxies
- Gateways
Clients do not need to know if they talk to the real server or an intermediary.
This is important for:
- Scaling your backend.
- Adding caching layers.
- Adding API gateways and security layers.
Example:
Client → API Gateway → Backend Services → Database
From the client's point of view, it still calls https://api.example.com/users, and does not care how many layers exist behind that URL.
6. Code on Demand (Optional)
REST allows, but does not require, the server to send executable code to the client.
Example:
- Server sends JavaScript to a web browser that runs on the client side.
In modern web APIs, this is usually not relevant, especially for mobile or backend to backend APIs. You can safely ignore this constraint for most backend REST API work.
REST vs "RESTful" APIs
Many APIs call themselves REST APIs or RESTful APIs even if they only follow some of the REST ideas.
Typical properties of an API that people call "RESTful":
- Uses HTTP.
- Uses resource based URLs with nouns.
- Uses HTTP methods (
GET,POST,PUT,PATCH,DELETE) logically. - Returns JSON.
- Uses proper HTTP status codes.
Many of these APIs:
- Are not fully stateless, or
- Do not use HATEOAS, or
- Have URLs with verbs or custom patterns at times.
You do not need to be a "REST police officer." Your goal as a backend developer is:
- Understand the original REST ideas.
- Apply them in a practical, consistent way.
- Make your API clear and predictable for clients.
Examples of RESTful Interactions
To make the ideas concrete, here are some common API interactions and how they look in a RESTful style.
Example: Users Resource
Assume we have a User resource.
| Action | HTTP Method | URL | Request Body | Response Status |
|---|---|---|---|---|
| List users | GET | /users | None | 200 OK |
| Create a new user | POST | /users | JSON with user data | 201 Created |
| Get one user | GET | /users/123 | None | 200 OK or 404 |
| Replace a user | PUT | /users/123 | Full JSON representation | 200 OK or 204 |
| Update part of user | PATCH | /users/123 | Partial JSON representation | 200 OK or 204 |
| Delete a user | DELETE | /users/123 | None | 204 No Content |
Example requests and responses:
1. List users
GET /users HTTP/1.1
Host: api.example.com
Accept: application/jsonHTTP/1.1 200 OK
Content-Type: application/json
[
{ "id": 1, "name": "Alice" },
{ "id": 2, "name": "Bob" }
]2. Create user
POST /users HTTP/1.1
Host: api.example.com
Content-Type: application/json
{
"name": "Charlie"
}HTTP/1.1 201 Created
Content-Type: application/json
Location: /users/3
{
"id": 3,
"name": "Charlie"
}3. Get user
GET /users/3 HTTP/1.1
Host: api.example.com
Accept: application/jsonHTTP/1.1 200 OK
Content-Type: application/json
{
"id": 3,
"name": "Charlie"
}4. Delete user
DELETE /users/3 HTTP/1.1
Host: api.example.comHTTP/1.1 204 No ContentThese examples show how REST uses HTTP methods and status codes to express intent and results, without inventing custom actions.
REST Compared to Other Styles
You may hear about other API styles. REST is not the only one.
Some examples:
- RPC (Remote Procedure Call)
Focuses on calling functions or procedures, often with verb oriented endpoints.
Example:POST /CreateUser,POST /SendEmail. - GraphQL
A query language for APIs. The client asks exactly for the data it needs.
Usually uses a single endpoint likePOST /graphql. - gRPC
Uses Protocol Buffers and HTTP/2. Very efficient for service to service communication.
REST is simple, human readable, and works very well with HTTP. This is why it is the most common style for public web APIs and for many backend systems.
Benefits of REST for Backend Developers
Using REST ideas in your backend gives you:
- Simplicity
URLs map to resources, methods map to actions. Easy to reason about. - Predictability
API clients can guess endpoints and behavior more easily. - Scalability
Stateless constraint and layered system make scaling simpler. - Interoperability
Any HTTP capable client can use your API, from web browsers to IoT devices. - Reuse of HTTP features
You get caching, status codes, headers, security mechanisms, and tools "for free."
If you use HTTP, you should usually design your API in a RESTful way to benefit from HTTP's features and conventions.
What You Need to Remember Now
For now, you do not need to memorize every theoretical detail of REST. Instead, remember these practical points:
- Think in resources (nouns) and use meaningful URIs.
- Use appropriate HTTP methods for each operation.
- Make each request self contained and avoid hidden server state.
- Use correct HTTP status codes.
- Make responses self descriptive, with clear headers and JSON bodies.
- Design your API so it can be cached when appropriate.
In the next chapters, you will apply these ideas to design resources, endpoints, and HTTP methods for real REST APIs.
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!