27.3. GraphQL
Table of Contents
Why GraphQL Exists
REST works well for many APIs, but it has some common pain points:
- Overfetching: You get more data than you need.
Example:/users/1returns user, posts, comments, avatar, even if you only need the user’s name. - Underfetching: You do not get enough data and must call multiple endpoints.
Example: You call/users/1then/users/1/poststhen/posts/{id}/commentsto build a single page. - Too many endpoints: You often create many URLs like
/users,/users/{id},/users/{id}/details,/users/{id}/posts, and so on.
GraphQL was created to solve these problems by letting clients ask exactly for the data they need, in a single request, over a single endpoint.
Key idea: In GraphQL, the client defines the shape of the response. The server provides a flexible schema, and the client picks fields from that schema in each query.
GraphQL is a query language for APIs and a runtime that executes those queries against your data, no matter where that data comes from (database, other APIs, files, etc.).
How GraphQL Works at a High Level
A GraphQL backend usually has:
- A single HTTP endpoint
Often/graphql, usually via POST. - A schema
The schema describes types, fields, and operations that clients can perform. - Resolvers
A resolver is a function that knows how to fetch the data for a specific field.
A GraphQL request is sent as a JSON body like:
{
"query": "{ hello }"
}
The server parses the query string, checks it against the schema, calls resolvers, then returns JSON like:
{
"data": {
"hello": "Hello world"
}
}The GraphQL Schema
The schema is the contract between the client and the server.
You normally write it using the GraphQL Schema Definition Language (SDL).
Example schema:
type User {
id: ID!
username: String!
email: String!
age: Int
}
type Query {
user(id: ID!): User
users: [User!]!
}Important parts:
type User { ... }defines an object type with fields.ID,String,Int,Float,Booleanare built-in scalar types.!means the value cannot be null.
Example:ID!is non-nullable.[User!]!is a non-null list of non-null users.
Rule: In GraphQL, the schema defines what clients can ask for. If it is not in the schema, clients cannot query it.
You also define entry points:
type Queryfor read operations.type Mutationfor write operations (create, update, delete).type Subscriptionfor real-time data over WebSockets.
Queries: Getting Data
A GraphQL query looks like the JSON shape you want to receive, but in a GraphQL-specific syntax.
Example schema:
type Post {
id: ID!
title: String!
body: String!
author: User!
}
type User {
id: ID!
username: String!
posts: [Post!]!
}
type Query {
user(id: ID!): User
}Example query:
query {
user(id: "1") {
id
username
posts {
id
title
}
}
}Example response:
{
"data": {
"user": {
"id": "1",
"username": "alice",
"posts": [
{ "id": "10", "title": "First post" },
{ "id": "11", "title": "Second post" }
]
}
}
}Notice:
- The response structure matches the query.
- You can select nested fields across relationships in a single request.
If you only need the username, you ask only for that:
query {
user(id: "1") {
username
}
}Response:
{
"data": {
"user": {
"username": "alice"
}
}
}Mutations: Writing Data
Reads use Query. Writes use Mutation.
Example schema additions:
input CreatePostInput {
title: String!
body: String!
authorId: ID!
}
type Post {
id: ID!
title: String!
body: String!
author: User!
}
type Mutation {
createPost(input: CreatePostInput!): Post!
}Example mutation:
mutation {
createPost(
input: {
title: "My first GraphQL post"
body: "This is cool"
authorId: "1"
}
) {
id
title
author {
username
}
}
}Response:
{
"data": {
"createPost": {
"id": "42",
"title": "My first GraphQL post",
"author": {
"username": "alice"
}
}
}
}Things to notice:
- You can send complex input using
inputtypes. - The mutation result can include nested fields, not just a success flag.
Variables: Reusing Queries and Mutations
Hardcoding IDs and values in queries is not practical. GraphQL supports variables.
Example mutation with variables:
mutation CreatePost($input: CreatePostInput!) {
createPost(input: $input) {
id
title
}
}You send it with a JSON body like:
{
"query": "mutation CreatePost($input: CreatePostInput!) { createPost(input: $input) { id title } }",
"variables": {
"input": {
"title": "Another post",
"body": "Content",
"authorId": "1"
}
}
}You can also use variables in queries:
query GetUser($id: ID!) {
user(id: $id) {
id
username
}
}Fields, Arguments, and Aliases
Field arguments
Fields can take arguments, similar to function parameters.
Schema:
type Query {
posts(limit: Int, offset: Int): [Post!]!
}Query:
query {
posts(limit: 10, offset: 20) {
id
title
}
}Aliases
Sometimes you want to query the same field multiple times with different arguments. You can use aliases.
Schema:
type Query {
user(id: ID!): User
}Query with aliases:
query {
firstUser: user(id: "1") {
username
}
secondUser: user(id: "2") {
username
}
}Response:
{
"data": {
"firstUser": { "username": "alice" },
"secondUser": { "username": "bob" }
}
}Fragments: Reusing Field Selections
If you repeat the same group of fields many times, use a fragment.
Example:
fragment UserFields on User {
id
username
email
}
query {
users {
...UserFields
}
user(id: "1") {
...UserFields
}
}This helps keep large queries readable and consistent.
Comparing GraphQL and REST
| Aspect | REST | GraphQL |
|---|---|---|
| Endpoint structure | Many endpoints, one per resource or action | Usually a single /graphql endpoint |
| Data shape | Fixed per endpoint | Defined by the client in each query |
| Overfetching / underfetching | Common issue | Greatly reduced, client asks for exactly what it needs |
| HTTP methods | Uses verbs: GET, POST, PUT, PATCH, DELETE | Usually POST (sometimes GET for simple queries) |
| Versioning | Often /v1, /v2 APIs | Usually evolve schema without versioned URLs |
| Documentation | Swagger / OpenAPI, manual docs | Schema is introspectable and self-documenting |
| Caching | HTTP status codes and headers, URL-based | Trickier, often needs custom caching or client-side tools |
| Error handling | Via HTTP status codes | Mixed data and errors in one JSON response |
Important: GraphQL is not a replacement for HTTP. It sits on top of HTTP and uses it as a transport layer.
Basic Error Handling in GraphQL
GraphQL responses always return a top-level data key, and optionally an errors key.
Example error response:
{
"data": {
"user": null
},
"errors": [
{
"message": "User not found",
"path": ["user"],
"locations": [{ "line": 2, "column": 3 }]
}
]
}data.userisnullbecause the resolver failed.errorscontains details about what went wrong.
You usually do not use HTTP 4xx / 5xx for validation or application errors inside GraphQL. The HTTP status is often 200, and the error lives in the errors array. Some implementations also use 400 or 500 when the query itself is invalid.
How Resolvers Work (Conceptually)
A resolver is a function that GraphQL calls to produce the value of a field.
For example, with this schema:
type User {
id: ID!
username: String!
}
type Query {
user(id: ID!): User
}Behind the scenes, you might have something like this (pseudo-code):
def resolve_user(root, info, id):
return db.get_user_by_id(id)Each field on each type can have its own resolver. If you do not define a resolver for a field, a default resolver usually returns the corresponding property from the parent object.
Resolvers give you flexibility: you can fetch from a database, call another REST API, read a file, or even compute the value.
Example: Simple GraphQL Server Concept
Here is a small conceptual Python example using a GraphQL library style, to make things concrete. This is not tied to a specific framework, but shows the roles:
# Schema (SDL)
schema_str = """
type User {
id: ID!
username: String!
}
type Query {
user(id: ID!): User
}
"""
# Data source for demo
USERS = {
"1": {"id": "1", "username": "alice"},
"2": {"id": "2", "username": "bob"},
}
# Resolver
def resolve_user(root, info, id):
return USERS.get(id)
# Wiring (pseudo-code)
schema = build_schema(schema_str)
schema.set_resolver("Query", "user", resolve_user)
# HTTP handler (very simplified pseudo-code)
def handle_request(http_request):
body = json.loads(http_request.body)
query = body["query"]
variables = body.get("variables")
result = schema.execute(query, variable_values=variables)
return json_response(result.to_dict())Flow:
- Client sends a GraphQL query to
/graphql. - Server parses the query and matches it to the schema.
- For each field, the corresponding resolver is called.
- Results are combined into the final JSON response.
When to Use GraphQL vs REST
GraphQL can be very helpful when:
- You have complex UIs that need data from many related resources.
- Different clients (web, mobile, internal tools) need different subsets of data.
- You want strong typing and introspection for your API.
REST can be simpler and more natural when:
- Your API is very small and straightforward.
- You benefit heavily from built-in HTTP caching and status codes.
- Your clients are few and have stable data needs.
In real projects, it is common to:
- Use REST for some parts of your system.
- Use GraphQL as an aggregation layer on top of existing REST / microservices.
Summary
- GraphQL is a query language and runtime for APIs that lets clients request exactly the data they need.
- The schema defines types, fields, and entry points:
Query,Mutation, and optionallySubscription. - Clients send queries for reads and mutations for writes, often with variables for dynamic values.
- Responses always include
dataand can includeerrors. - GraphQL typically uses one HTTP endpoint, and the shape of the response is controlled by the query, not by the server endpoint.
This gives you a flexible and powerful way to design APIs, especially for complex applications with many data relationships and multiple client types.
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!