7.3. Resources and Endpoints
Table of Contents
Understanding Resources and Endpoints
In REST, almost everything starts with two ideas: resources and endpoints. If you understand these well, the rest of REST becomes much easier.
This chapter focuses only on what resources and endpoints are, how to design them, and many concrete examples. Other topics, like HTTP methods and status codes, have their own chapters.
What Is a Resource?
A resource is an object or concept in your system that you want to expose through your API.
You can think of a resource as "a kind of thing" that your API works with.
Some common resource examples:
| Domain | Possible resources |
|---|---|
| Task manager | users, tasks, projects, comments |
| E commerce | products, categories, orders, carts, reviews |
| Blogging platform | posts, users, comments, tags |
| School system | students, courses, enrollments, teachers |
| Social network | users, posts, likes, followers, messages |
You rarely expose every internal object as a resource. You choose the things that make sense to clients of the API.
Key points about resources:
- A resource represents a type of thing, not a single item.
- Example: “tasks” is a resource type. A particular task with id
42is a resource instance. - Resources can be real world things or conceptual things.
- Real world:
user,product,order. - Conceptual:
auth-token,report,search-result. - Resources usually have:
- A name (like
usersororders) - A representation (usually JSON data)
- A way to identify individual items (like an
id)
Important rule:
Think first about resources (the nouns), then about how to operate on them (the verbs / HTTP methods).
Do not start with actions like /createUser or /deleteOrder. Design the things first.
Identifying Resources
To identify resources in a system, imagine you are explaining your application without any code.
Example: Task management app. You might say:
- "Users can create tasks"
- "Tasks can belong to projects"
- "Each task can have comments and tags"
From this description, you can spot the nouns:
userstasksprojectscommentstags
These are good candidates for resources.
Exercise in your mind
Take a simple "online course platform" and list candidates:
- "Students enroll in courses"
- "Courses have lessons"
- "Lessons have quizzes"
- "Teachers create courses"
Nouns:
- students
- courses
- lessons
- quizzes
- teachers
- enrollments (this is a relationship, but often becomes a resource too)
You do not have to expose all of them. You choose what is useful:
- Maybe you expose
students,courses,lessons,enrollments. - Maybe you hide
teachersbehind an admin API.
What Is an Endpoint?
An endpoint is a URL path that represents a resource (or resources) in your API.
Formally, an endpoint is the combination of:
- A URL path, for example
/usersor/tasks/42/comments - An HTTP method, for example
GETorPOST
You will study methods in detail in other chapters, but for now you can think:
GET /resource→ retrievePOST /resource→ createPUT/PATCH /resource/id→ updateDELETE /resource/id→ delete
Examples of endpoints:
| Endpoint | What it refers to |
|---|---|
GET /users | the collection of users |
POST /users | the collection of users (create a new one) |
GET /users/10 | a single user with id 10 |
GET /projects/5/tasks | tasks that belong to project 5 |
DELETE /orders/99 | the order with id 99 |
Notice that the path itself is usually just nouns.
The action is expressed by the HTTP method, not by the path.
Important rule:
Endpoints should use nouns in URLs and HTTP methods for actions, for example:
POST /users(create user)
Not:/createUser
Collections vs Individual Resources
Usually, each resource type has:
- A collection endpoint
- One or more single resource endpoints
Collection endpoints
A collection is the list or set of all items of a resource.
Typical patterns:
GET /tasks→ list all tasks, or tasks for the current userPOST /tasks→ create a new task
The same applies for other resources:
| Resource | Collection endpoints |
|---|---|
| users | GET /users, POST /users |
| orders | GET /orders, POST /orders |
| products | GET /products, POST /products |
| comments | GET /comments, POST /comments |
Later, you may add query parameters for filtering, pagination, and so on, but the base collection endpoint is usually just the plural noun.
Single resource endpoints
A single resource endpoint refers to one specific item, often by ID.
Typical patterns:
GET /tasks/{task_id}→ get one taskPUT /tasks/{task_id}/PATCH /tasks/{task_id}→ update an existing taskDELETE /tasks/{task_id}→ delete a task
Examples for different resources:
| Resource | Single resource endpoints (examples) |
|---|---|
| user | GET /users/123, PATCH /users/123 |
| order | GET /orders/55, DELETE /orders/55 |
| product | GET /products/999, PUT /products/999 |
Here {task_id}, {user_id}, {order_id} are path parameters that identify a particular item of the resource.
You will learn path parameters in more detail in another chapter. For now, just understand that they are part of the URL and used to uniquely identify a resource instance.
Naming Resources and Endpoints
Naming is important for a clean API. There is no single universal rulebook, but there are strong conventions that most APIs follow.
Use plural nouns for collections
Most APIs use plural nouns for the main collection endpoints.
Good examples:
/users/tasks/orders/products/posts/comments
Then single items are under those collections:
/users/1/tasks/42/orders/2023001
Some APIs use singular nouns (like /user), but plural is far more common and easier to reason about:
/users= collection/users/{id}= single item in that collection
Important rule:
Use plural nouns for top level resource collections: /users, /orders, /products.
Keep it consistent across your entire API.
Use lowercase and hyphens
For readability and consistency:
- Use lowercase letters
- Use hyphens
-to separate words, not underscores_or spaces - Avoid camelCase in URLs
Examples:
| Prefer | Avoid |
|---|---|
/user-profiles | /userProfiles |
/order-items | /order_items |
/product-reviews | /ProductReviews |
You may see underscores in some APIs, but hyphens are more common in URL paths.
Avoid verbs in URLs
The path represents resources, which are nouns, not actions.
Good:
POST /usersto create a userDELETE /users/1to delete a userPOST /orders/123/cancel(special case, discussed later)
Avoid:
POST /createUserGET /getAllUsersPOST /deleteUser
The HTTP method already tells you the action. The endpoint path should describe what the method is applied to.
Consistent naming patterns
Try to keep resource names consistent:
- Use the same word across your API:
- Do not mix
/usersand/accountsfor the same thing. - Do not mix singular and plural randomly:
- Pick
/productsrather than having both/productsand/product.
Hierarchical Endpoints and Subresources
Some resources have a natural parent child relationship. For example:
- A project has many tasks
- A post has many comments
- A user has many orders
In these cases, you can express the relationship in your endpoints.
Parent-child collections
Examples:
GET /projects/10/tasks→ tasks that belong to project 10POST /projects/10/tasks→ create a new task under project 10GET /posts/3/comments→ comments for post 3POST /posts/3/comments→ add a comment to post 3
Here, tasks and comments are often called subresources or nested resources of the parent.
Individual child resources
Sometimes you also access an individual child resource through the parent.
For example:
GET /projects/10/tasks/5
Task 5, which belongs to project 10.DELETE /posts/3/comments/8
Comment 8 on post 3.
Technically, GET /tasks/5 and GET /projects/10/tasks/5 might refer to the same task.
Some APIs:
- Choose only flat endpoints, like
/tasks/5 - Others allow both flat and nested forms
As a beginner, a simple and common choice is:
- Use flat endpoints for normal CRUD:
GET /tasks,GET /tasks/5, etc.- Use nested endpoints when the parent is always needed or when listing children:
GET /projects/10/tasks
When to nest, when not to nest
Nesting is useful when:
- The child resource only makes sense in the context of a parent.
- Example:
commentsmake sense only for apost. - You usually operate on children through the parent.
- Example: listing tasks per project.
Too much nesting becomes confusing:
/users/1/projects/10/tasks/5/comments/2is hard to read and maintain.
A simple guideline:
- Try to keep nesting at 1 level deep:
/projects/{project_id}/tasks/posts/{post_id}/comments- Avoid more than 2 or 3 levels of nesting.
Relationships and Linking Resources
Resources often have relationships with each other.
Common relationships:
- One to many
- One user has many orders:
GET /users/1/orders - Many to many
- Many users can join many groups:
GET /users/1/groups,GET /groups/5/users
You can represent these relationships in different ways.
Example: Users and Orders
Resources:
usersorders
Possible endpoints:
| Purpose | Endpoint |
|---|---|
| List all users | GET /users |
| Get one user | GET /users/{user_id} |
| List all orders | GET /orders |
| Get one order | GET /orders/{order_id} |
| List orders for a specific user | GET /users/{user_id}/orders |
The API response for GET /users/1 might include links to related resources, for example:
{
"id": 1,
"name": "Alice",
"email": "alice@example.com",
"links": {
"self": "/users/1",
"orders": "/users/1/orders"
}
}This is one way of making relationships discoverable.
Example: Many to many with join resources
Sometimes, a relationship itself becomes its own resource.
Example: A user can enroll in many courses, and a course has many users. The enrollment can be a resource:
studentscoursesenrollments
Possible endpoints:
POST /enrollmentswith body{ "student_id": 1, "course_id": 5 }GET /students/1/enrollmentsGET /courses/5/enrollments
Here, enrollments is a resource that connects two other resources.
Representing a Resource
An endpoint returns a representation of a resource, usually in JSON.
Example resource: task
A typical JSON representation:
{
"id": 42,
"title": "Write API chapter",
"description": "Explain resources and endpoints",
"status": "in_progress",
"project_id": 3,
"created_at": "2026-08-27T10:15:00Z",
"updated_at": "2026-08-27T11:00:00Z"
}Different endpoints can return different views of the same resource:
GET /tasks/42might return full details.GET /tasksmight return a shorter summary for each task:
[
{
"id": 42,
"title": "Write API chapter",
"status": "in_progress"
},
{
"id": 43,
"title": "Review examples",
"status": "todo"
}
]You will study response models and validation in other chapters. Here, focus on the idea that each endpoint is tied to a resource and returns a sensible representation of it.
Examples of Resource and Endpoint Design
To make these ideas concrete, look at some mini APIs.
Example 1: Simple Task API
Resources:
userstasksprojects
Endpoints:
| Purpose | Endpoint |
|---|---|
| List all tasks | GET /tasks |
| Create a new task | POST /tasks |
| Get a single task | GET /tasks/{task_id} |
| Update a task | PATCH /tasks/{task_id} |
| Delete a task | DELETE /tasks/{task_id} |
| List tasks for a specific project | GET /projects/{project_id}/tasks |
| List projects | GET /projects |
| Create a project | POST /projects |
| Get a project | GET /projects/{project_id} |
Notice:
- Collections:
/tasks,/projects - Singles:
/tasks/{id},/projects/{id} - Nested:
/projects/{id}/tasks
No verbs in URLs, only nouns.
Example 2: E commerce API
Resources:
productscategoriescartscart-itemsordersusers
Some endpoints:
| Purpose | Endpoint |
|---|---|
| Browse products | GET /products |
| Get a product | GET /products/{product_id} |
| Browse products in a category | GET /categories/{category_id}/products |
| Get all categories | GET /categories |
| View current user's cart | GET /carts/current |
| Add item to cart | POST /carts/current/items |
| Update quantity of an item in cart | PATCH /carts/current/items/{item_id} |
| Remove item from cart | DELETE /carts/current/items/{item_id} |
| Place an order from current cart | POST /orders |
| Get user's orders | GET /users/{user_id}/orders |
Note a special case: carts/current. That is a resource that represents "the current user's cart," which is a bit more conceptual but still a resource. We will talk about such special resources next.
Special Resources and Action-like Endpoints
Sometimes you need to represent operations that are not simple CRUD on a single resource. Examples:
- Login
- Password reset
- "Cancel" an order
- "Complete" a task
There are different ways to model these.
Conceptual resources
You can model some actions as resources themselves.
Examples:
- An authentication token can be a resource:
POST /tokenswith username and password to create a tokenDELETE /tokens/currentto log out- A password reset request can be a resource:
POST /password-reset-requeststo ask for a reset email
Even though these feel like "actions," you expose them as resources that you create or delete.
Action subresources
Sometimes people use a subresource that looks like an action.
For example, canceling an order:
POST /orders/123/cancel
Here, cancel behaves like a subresource that represents "the cancel operation for this order." The HTTP method POST is still used. This is common and practical, even if it is not purely "resource oriented."
Other examples:
POST /tasks/42/completePOST /users/10/lockPOST /users/10/unlock
You should not overuse this pattern, but it is acceptable for important actions that do not fit perfectly into standard CRUD.
Versioning and Endpoint Structure (Preview)
You will learn API versioning in a dedicated chapter, but here is how resources and endpoints often look when versioned.
Common pattern:
GET /v1/usersGET /v1/tasks/42
The resource names and endpoint structure stay the same, but you prefix them with a version, usually as a first path segment.
Example:
| Version 1 | Version 2 |
|---|---|
GET /v1/tasks | GET /v2/tasks |
GET /v1/users/{user_id}/tasks | GET /v2/users/{user_id}/tasks |
The idea is that clients who use /v1/... are not broken by changes in /v2/....
Checklist for Designing Resources and Endpoints
When designing a new REST API, you can walk through this checklist.
- List your domain nouns.
- What are the main things in your system?
- Example: users, tasks, projects, comments.
- Decide which nouns become resources.
- Not every internal object must be exposed.
- Start with the biggest, most important ones.
- Name collections with plural nouns.
/users,/tasks,/projects- Define collection and single resource endpoints.
- Collection:
GET /tasks,POST /tasks - Single:
GET /tasks/{task_id},PATCH /tasks/{task_id},DELETE /tasks/{task_id} - Identify relationships and nested endpoints.
- Parent child:
GET /projects/{project_id}/tasks,GET /posts/{post_id}/comments - Avoid verbs in paths.
- Use HTTP methods to express actions.
- Only use action-like subresources when you really need them:
/orders/{id}/cancel. - Keep nesting shallow.
- Prefer at most one level:
/projects/{id}/tasks. - Avoid very deep URLs.
- Choose consistent naming style.
- Lowercase, hyphens, plural nouns.
If you follow this checklist, your resources and endpoints will be much easier to understand, both for you and for other developers who use your API.
By now you should be comfortable with the ideas of resources and endpoints, how to identify resources in a domain, and how to map them to clear, consistent URLs. In the following chapters, you will see how HTTP methods, status codes, and other REST concepts build on this foundation.
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!