20.10. Grafana
Table of Contents
Why Grafana Matters for Backend Developers
Grafana is a visualization and dashboard tool. It takes metrics, logs, or traces from different data sources and shows them in graphs, tables, and alerts.
In a backend system, Grafana usually sits on top of tools like Prometheus, Loki, Elasticsearch, or other databases. You use it to see how your application behaves in real time, and to investigate problems.
Typical uses:
- Watch response times and error rates of APIs
- See CPU, memory, and disk usage of servers and containers
- Track database performance and queue backlogs
- Build operations dashboards for on‑call engineers
Grafana does not collect metrics itself. It connects to existing data sources and visualizes their data.
Key idea: Grafana is a read‑only visualization and alerting layer on top of other monitoring and logging systems. It does not replace them, it uses them.
Grafana Architecture Basics
From a backend perspective, you can think of Grafana as a web app with:
- A frontend, where you build and view dashboards
- A backend, which:
- Stores configuration (dashboards, users, data sources) in a database
- Queries external data sources using their APIs
- Evaluates alert rules and sends notifications
Typical components:
| Component | Role |
|---|---|
| Grafana server | Main process, serves UI, handles API, alerts |
| Database | Stores dashboards, users, data source configs |
| Data sources | Store metrics/logs (Prometheus, Loki, PostgreSQL) |
| Notification chan. | Email, Slack, etc for alerts |
Common data sources in backend projects:
- Prometheus for metrics (requests per second, latency, CPU)
- Loki or Elasticsearch for logs
- PostgreSQL / MySQL when you want to graph data from your app DB
Installing Grafana (Developer View)
The exact install method will depend on your OS and environment. As a backend developer, you mainly need to know:
- How to run Grafana locally for development
- How to run Grafana in Docker
- Where configuration and data are stored
Running Grafana with Docker
For local experiments, Docker is usually easiest.
docker-compose.yml example:
version: "3.8"
services:
grafana:
image: grafana/grafana:latest
container_name: grafana
ports:
- "3000:3000"
environment:
- GF_SECURITY_ADMIN_USER=admin
- GF_SECURITY_ADMIN_PASSWORD=admin
volumes:
- grafana-storage:/var/lib/grafana
volumes:
grafana-storage:Then:
docker compose up -d
Open http://localhost:3000 and log in with admin / admin (or your env values).
Basic Configuration Files
Grafana configuration is usually in grafana.ini or environment variables starting with GF_.
Examples:
GF_SERVER_ROOT_URL=http://example.com/grafanaGF_SECURITY_ADMIN_PASSWORD=supersecret
In production, these go into your deployment system (Docker, Kubernetes, etc.).
Connecting Data Sources
Grafana can connect to many backends, but as a backend engineer, you will most often integrate:
- Prometheus for metrics
- Loki (or similar) for logs
- Sometimes PostgreSQL for business or diagnostic data
Adding a Prometheus Data Source
Assume Prometheus is running at http://prometheus:9090 inside your Docker network.
In Grafana UI:
- Go to Configuration → Data sources
- Click Add data source
- Select Prometheus
- Set URL to
http://prometheus:9090 - Click Save & test
If you prefer an example with plain Docker:
services:
prometheus:
image: prom/prometheus:latest
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
grafana:
image: grafana/grafana:latest
ports:
- "3000:3000"
depends_on:
- prometheus
Then use http://prometheus:9090 as the URL from Grafana’s point of view.
Adding a PostgreSQL Data Source
You can query your app database directly, for example to show:
- Number of users
- Orders per day
- Queue sizes stored in a table
Steps:
- Configuration → Data sources → Add data source
- Select PostgreSQL
- Set host, database, user, password
- Choose correct SSL and time zone options
- Save & test
Example connection settings:
| Field | Value |
|---|---|
| Host | postgres:5432 |
| Database | my_app_db |
| User | grafana_reader |
| TLS/SSL | As required by your setup |
In PostgreSQL, you usually want a read‑only user:
CREATE USER grafana_reader WITH PASSWORD 'strongpassword';
GRANT CONNECT ON DATABASE my_app_db TO grafana_reader;
GRANT USAGE ON SCHEMA public TO grafana_reader;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO grafana_reader;Building Dashboards
Grafana dashboards are collections of panels. Each panel shows data from one or more queries.
Basic Panel Types
Common panel types useful for backends:
| Panel type | Good for |
|---|---|
| Time series | Latency, throughput, CPU usage over time |
| Gauge | Single value like error rate or usage |
| Bar chart | Comparing values (top endpoints by errors) |
| Table | Log summaries, queries, raw metrics |
| Stat | Single KPI (current users, RPS) |
Example: API Latency Dashboard with Prometheus
Assume you have a Prometheus metric:
http_request_duration_seconds_bucket{path="/api/tasks", method="GET", le="..."}You can create panels like:
- P95 latency (ms):
PromQL:
histogram_quantile(
0.95,
sum(rate(http_request_duration_seconds_bucket[5m])) by (le)
) * 1000- Requests per second:
sum(rate(http_requests_total[5m]))- Error rate:
(
sum(rate(http_requests_total{status=~"5.."}[5m]))
/
sum(rate(http_requests_total[5m]))
) * 100Key metrics to visualize for a backend:
- Latency: P50, P95, P99 response times
- Traffic: Requests per second, concurrent users
- Errors: 4xx and 5xx error rates
- Saturation: CPU, memory, DB connections, queue sizes
Example: Business Metrics with PostgreSQL
Suppose you have a table:
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
created_at TIMESTAMP NOT NULL,
total_amount NUMERIC(10, 2) NOT NULL,
status TEXT NOT NULL
);You can use a PostgreSQL panel query:
SELECT
date_trunc('day', created_at) AS time,
SUM(total_amount) AS total_revenue
FROM orders
WHERE $__timeFilter(created_at)
GROUP BY time
ORDER BY time;
Here __$timeFilter(created_at) is a Grafana macro that applies the current dashboard time range.
This will show a time series of daily revenue.
Variables and Reusable Dashboards
Grafana variables let you change what a dashboard shows without editing the panels.
You can create variables for:
- Environment, for example
dev,staging,prod - Service name
- HTTP path
Example: Environment Variable
- Dashboard settings → Variables → New
- Name:
env - Type:
Custom - Values:
dev, staging, prod
Then in PromQL use:
sum(rate(http_requests_total{env="$env"}[5m]))
Switching the dropdown between dev, staging, prod will instantly change all panels.
Example: Path Variable from Prometheus
Create a variable:
- Type:
Query - Data source: Prometheus
- Query:
label_values(http_requests_total, path)
Panels can then filter with {path="$path"}.
Alerts with Grafana
Grafana can evaluate alert rules on your metric queries and send notifications.
Alerting Concepts
- Alert rule: A condition evaluated periodically, like "P95 latency > 500 ms"
- Contact point: Where to send alerts, such as email or Slack
- Notification policy: How alerts are routed and grouped
Example: High Error Rate Alert
Imagine you want an alert if the error rate is above 5 percent for 10 minutes.
PromQL expression:
(
sum(rate(http_requests_total{status=~"5.."}[5m]))
/
sum(rate(http_requests_total[5m]))
) * 100In Grafana alert rule:
- Condition:
WHEN avg() OF query(A, 10m, now) IS ABOVE 5 - Evaluation interval:
1m - For:
10m
This means: average error rate over 10 minutes is above 5 percent.
Alert rules should focus on user‑visible problems, not just technical details.
Examples:
- "Error rate > 5 percent"
- "P95 latency > 1 s"
- "DB connections > 90 percent of pool"
Simple Notification Setup
- Go to Alerting → Contact points
- Create a contact point, for example:
- Email: oncall@example.com
- Slack: webhook URL
- Go to Alerting → Notification policies
- Set default policy to send all alerts to that contact point
Now, when a rule fires, Grafana sends notifications.
Logs and Traces with Grafana
Grafana can also show logs and traces if you use tools like Loki, Elasticsearch, or Tempo.
Logs with Loki (Overview)
Typical setup:
- Applications write logs to stdout as JSON
- Loki ingests logs
- Grafana connects to Loki as a data source
Log query example in Loki:
{app="api", level="error"} |= "database"You can:
- Filter logs by labels (app, env, instance)
- Search in log message content
- Correlate logs with metrics by time
Traces with Tempo (High‑Level)
If you use distributed tracing:
- Your services send traces to a backend like Tempo or Jaeger
- Grafana can show trace spans and link to metrics and logs
This is especially helpful for microservices architectures.
Example: Metrics for a FastAPI Application
Assume you have a FastAPI app with Prometheus metrics using prometheus_client.
from fastapi import FastAPI
from prometheus_client import Counter, Histogram, generate_latest
from prometheus_client import CONTENT_TYPE_LATEST
import time
from starlette.responses import Response
app = FastAPI()
REQUEST_COUNT = Counter(
"http_requests_total",
"Total HTTP requests",
["method", "path", "status"]
)
REQUEST_LATENCY = Histogram(
"http_request_duration_seconds",
"Request latency",
["method", "path"]
)
@app.middleware("http")
async def metrics_middleware(request, call_next):
method = request.method
path = request.url.path
start = time.time()
response = await call_next(request)
latency = time.time() - start
REQUEST_LATENCY.labels(method=method, path=path).observe(latency)
REQUEST_COUNT.labels(
method=method,
path=path,
status=response.status_code
).inc()
return response
@app.get("/metrics")
def metrics():
return Response(
generate_latest(),
media_type=CONTENT_TYPE_LATEST
)Steps to visualize in Grafana:
- Run Prometheus, scrape
http://api:8000/metrics - Connect Grafana to Prometheus
- Create a dashboard with:
- P95 latency per path using
http_request_duration_seconds - Requests per second per path using
http_requests_total - Error rate (status >= 500)
Now you have a basic observability setup for your FastAPI backend.
Grafana in Production Environments
In production, you usually care about:
- Authentication and access control
- Connect Grafana to your SSO or OAuth provider
- Define viewer, editor, and admin permissions
- Data source permissions
- Use read‑only users for databases
- Do not give Grafana credentials that can modify data
- Dashboards as code
- Store JSON dashboard definitions in Git
- Provision dashboards using files or APIs
- Version dashboards and review changes
- Resource usage
- Grafana itself is light, but queries against Prometheus or DB can be heavy
- Optimize queries and limit panel refresh rates
Example of provisioning a data source via YAML (used with Docker/Kubernetes):
apiVersion: 1
datasources:
- name: Prometheus
type: prometheus
url: http://prometheus:9090
access: proxy
isDefault: true
This file goes under /etc/grafana/provisioning/datasources/ in the container.
How Grafana Fits Your Backend Monitoring Stack
A minimal, practical stack for a backend project often looks like:
| Concern | Tool | Role |
|---|---|---|
| Metrics | Prometheus | Collects metrics from services and systems |
| Logs | Loki or log system | Stores and indexes application logs |
| Tracing | Tempo (optional) | Stores distributed traces |
| View | Grafana | Dashboards, alerts, correlation |
Your job as a backend engineer is usually to:
- Expose metrics in your services
- Ensure logs contain useful structured fields (service name, request id, user id)
- Help design dashboards and alert rules that match real user problems
- Use Grafana when debugging incidents or performance issues
With this understanding, you can effectively use Grafana to monitor, debug, and improve your backend systems.
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!