Roadmaps

Backend & Deployment

  1. Backend Fundamentals

    1. Backend Fundamentals
    2. Client-server architecture
    3. HTTP / HTTPS
    4. Request / response lifecycle
    5. URLs, routes and endpoints
    6. HTTP methods
    7. Status codes
    8. Headers
    9. Query parameters
    10. Path parameters
    11. Request body
    12. JSON
    13. Content types
    14. REST API principles
    15. API versioning
    16. Idempotency
    17. Stateless vs stateful systems
    18. WebSockets for real-time applications

  2. Python Backend Fundamentals

    1. Python for backend development
    2. Virtual environments
    3. pip / package management
    4. Project structure
    5. Configuration and environment variables
    6. Logging
    7. Exceptions and error handling
    8. Type hints
    9. Pydantic
    10. Dependency management
    11. Application settings

  3. FastAPI

    1. FastAPI project structure
    2. Routes and path operations
    3. Request validation
    4. Pydantic models
    5. Response models
    6. Dependency injection
    7. Routers
    8. Middleware
    9. Exception handlers
    10. Authentication
    11. Authorization
    12. OpenAPI / Swagger
    13. API documentation
    14. File uploads
    15. Background tasks
    16. Async endpoints
    17. Sync endpoints
    18. ASGI
    19. Uvicorn

  4. Django

    1. Django project structure
    2. Apps
    3. URLs
    4. Views
    5. Request / response
    6. Templates
    7. Middleware
    8. Django settings
    9. Static and media files
    10. Management commands
    11. Django Admin
    12. Authentication
    13. Permissions
    14. Sessions
    15. Django REST Framework
    16. Serializers
    17. API views
    18. ViewSets
    19. Routers
    20. API authentication
    21. Permissions
    22. Pagination
    23. Filtering
    24. API documentation

  5. Sync & Async Programming

    1. Synchronous execution
    2. Asynchronous execution
    3. Blocking operations
    4. Non-blocking operations
    5. Event loop
    6. async / await
    7. Coroutines
    8. Tasks
    9. Concurrency vs parallelism
    10. I/O-bound operations
    11. CPU-bound operations
    12. Threads
    13. Processes
    14. Async database access
    15. Async HTTP requests
    16. When async actually helps
    17. Common async mistakes

  6. Databases Fundamentals

    1. Relational databases
    2. Tables
    3. Rows and columns
    4. Primary keys
    5. Foreign keys
    6. Relationships
    7. One-to-one
    8. One-to-many
    9. Many-to-many
    10. Constraints
    11. Indexes
    12. Transactions
    13. ACID
    14. Normalization
    15. SQL basics
    16. SELECT / INSERT / UPDATE / DELETE
    17. JOINs
    18. Aggregations
    19. Transactions and isolation

  7. SQLite

    1. SQLite architecture
    2. Local development databases
    3. SQLite limitations
    4. Database files
    5. Migrations
    6. When SQLite is appropriate
    7. When to move to PostgreSQL

  8. PostgreSQL

    1. PostgreSQL architecture
    2. Schemas
    3. Roles and permissions
    4. Data types
    5. Indexes
    6. Constraints
    7. Transactions
    8. PostgreSQL-specific features
    9. Query optimization
    10. Connection management
    11. Production databases

  9. ORM

    1. Object-relational mapping
    2. Models
    3. Fields
    4. Relationships
    5. Queries
    6. Querysets
    7. Lazy evaluation
    8. Migrations
    9. Transactions
    10. N+1 query problem
    11. Eager loading
    12. Raw SQL
    13. ORM vs SQL
    14. Django ORM
    15. SQLAlchemy
    16. FastAPI + SQLAlchemy
    17. Database sessions

  10. Users & Authentication

    1. User accounts
    2. Registration
    3. Login / logout
    4. Password hashing
    5. Password reset
    6. Sessions
    7. Cookies
    8. Secure cookies
    9. HTTP-only cookies
    10. SameSite
    11. CSRF
    12. JWT
    13. Access tokens
    14. Refresh tokens
    15. Authentication vs authorization
    16. Roles
    17. Permissions
    18. OAuth
    19. Google / GitHub login
    20. Account security

  11. HTTP & Server Architecture

    1. Web server
    2. Application server
    3. Reverse proxy
    4. Middleware
    5. Request lifecycle
    6. Routing
    7. Authentication middleware
    8. CORS
    9. Rate limiting
    10. Compression
    11. Static files
    12. Error handling
    13. Global exception handling
    14. Logging
    15. Monitoring
    16. Health checks
    17. Graceful shutdown

  12. API Development

    1. REST APIs
    2. Resource-oriented design
    3. CRUD
    4. Request validation
    5. Response serialization
    6. Error responses
    7. Pagination
    8. Filtering
    9. Sorting
    10. Search
    11. File uploads
    12. Webhooks
    13. API authentication
    14. API versioning
    15. OpenAPI
    16. Swagger
    17. Postman / Insomnia
    18. API testing

  13. Background Tasks

    1. Why background processing exists
    2. Long-running operations
    3. Scheduled tasks
    4. Email sending
    5. File processing
    6. Notifications
    7. Data processing
    8. Task queues
    9. Workers
    10. Retries
    11. Failed jobs
    12. Job status
    13. Scheduling

  14. Redis

    1. In-memory data storage
    2. Key-value model
    3. Caching
    4. TTL
    5. Sessions
    6. Rate limiting
    7. Pub/Sub
    8. Redis as a queue
    9. Redis data structures
    10. Cache invalidation
    11. Redis in production

  15. Message Queues

    1. Message brokers
    2. Producer / consumer model
    3. Queues
    4. Messages
    5. Workers
    6. Acknowledgements
    7. Retries
    8. Dead-letter queues
    9. RabbitMQ
    10. Redis-based queues
    11. Celery
    12. Task queues vs message brokers
    13. When to use each approach

  16. Workers

    1. Worker processes
    2. Celery
    3. Celery workers
    4. Celery Beat
    5. Redis / RabbitMQ as brokers
    6. Background jobs
    7. Scheduled jobs
    8. Retries
    9. Monitoring workers
    10. Worker scaling

  17. Testing Backend Applications

    1. Unit tests
    2. Integration tests
    3. API tests
    4. Database tests
    5. Authentication tests
    6. Mocking
    7. Fixtures
    8. Test databases
    9. Pytest
    10. Django Test Framework
    11. FastAPI testing
    12. Test-driven development basics

  18. Docker

    1. Containers
    2. Images
    3. Dockerfile
    4. Docker Compose
    5. Environment variables
    6. Volumes
    7. Networks
    8. Port mapping
    9. Multi-container applications
    10. Backend + PostgreSQL
    11. Backend + Redis
    12. Backend + worker
    13. Production containers
    14. Docker image optimization

  19. Linux & Server Fundamentals

    1. Linux filesystem
    2. Processes
    3. Users and permissions
    4. SSH
    5. Environment variables
    6. Ports
    7. Processes and services
    8. Logs
    9. System resources
    10. Networking basics
    11. DNS
    12. TCP/IP basics
    13. HTTP/HTTPS
    14. Firewall basics
    15. Reverse proxies
    16. Nginx
    17. Systemd
    18. Cron

  20. Deployment Fundamentals

    1. Development vs production
    2. Environment configuration
    3. Secrets
    4. Production databases
    5. Build process
    6. Application startup
    7. Process management
    8. Logs
    9. Health checks
    10. Domain names
    11. DNS
    12. SSL/TLS
    13. HTTPS
    14. Reverse proxy
    15. Backups
    16. Database migrations
    17. Deployment strategies
    18. Zero-downtime deployment

  21. Railway

    1. Railway projects
    2. Services
    3. PostgreSQL
    4. Environment variables
    5. Deployments
    6. GitHub integration
    7. Logs
    8. Domains
    9. Custom domains
    10. Service-to-service communication
    11. Redis
    12. Volumes
    13. Deployment configuration
    14. Production debugging

  22. Cloud Deployment

    1. Cloud computing concepts
    2. Virtual machines
    3. Managed databases
    4. Object storage
    5. Networking
    6. Load balancing
    7. Containers
    8. Serverless concepts
    9. Environment variables
    10. Secrets
    11. Monitoring

  23. AWS

    1. AWS fundamentals
    2. IAM
    3. EC2
    4. RDS
    5. S3
    6. CloudFront
    7. Route 53
    8. Load Balancer
    9. CloudWatch
    10. VPC basics
    11. Security groups
    12. ECS / containers
    13. Lambda overview
    14. Managed services
    15. Cost awareness

  24. Alternative Cloud Platforms

    1. Railway
    2. Render
    3. Fly.io
    4. DigitalOcean
    5. Hetzner
    6. AWS
    7. Cloudflare
    8. Vercel
    9. Choosing the right platform
    10. Managed vs self-managed infrastructure

  25. CI/CD

    1. Git
    2. GitHub
    3. GitHub Actions
    4. Automated testing
    5. Build pipelines
    6. Deployment pipelines
    7. Environment-specific deployments
    8. Secrets
    9. Rollbacks
    10. Database migrations during deployment
    11. Continuous integration
    12. Continuous deployment

  26. Security

    1. OWASP fundamentals
    2. SQL injection
    3. XSS
    4. CSRF
    5. Authentication security
    6. Authorization
    7. Password security
    8. Secrets management
    9. CORS
    10. Rate limiting
    11. Input validation
    12. File upload security
    13. Dependency vulnerabilities
    14. HTTPS
    15. Security headers
    16. Least privilege
    17. Secure database access

  27. Caching & Performance

    1. Why applications become slow
    2. Database bottlenecks
    3. Query optimization
    4. Indexes
    5. N+1 queries
    6. Application caching
    7. Redis caching
    8. HTTP caching
    9. CDN
    10. Connection pooling
    11. Async I/O
    12. Background jobs
    13. Load testing
    14. Profiling

  28. Microservices

    1. Monolith architecture
    2. Modular monolith
    3. Microservice architecture
    4. Service boundaries
    5. Service-to-service communication
    6. REST between services
    7. Internal APIs
    8. Message queues
    9. Event-driven architecture
    10. Service discovery
    11. Independent deployment
    12. Independent databases
    13. Distributed transactions
    14. Eventual consistency
    15. Failure between services
    16. Observability
    17. When NOT to use microservices

  29. Architecture & Design

    1. MVC
    2. Layered architecture
    3. Service layer
    4. Repository pattern
    5. Dependency injection
    6. Separation of concerns
    7. Domain logic
    8. Application logic
    9. Infrastructure layer
    10. SOLID principles
    11. Design patterns
    12. Clean Architecture overview
    13. Modular architecture
    14. Monolith vs microservices

  30. Laravel

    1. PHP backend fundamentals
    2. Laravel project structure
    3. Routing
    4. Controllers
    5. Middleware
    6. Requests / responses
    7. Validation
    8. Blade
    9. Authentication
    10. Authorization
    11. Eloquent ORM
    12. Migrations
    13. Relationships
    14. Query Builder
    15. API development
    16. Laravel Sanctum
    17. Queues
    18. Jobs
    19. Events
    20. Listeners
    21. Scheduling
    22. Cache
    23. Redis
    24. Laravel Artisan
    25. Laravel deployment
    26. Laravel vs Django
    27. Laravel vs FastAPI

  31. Production Project

    1. Design backend architecture
    2. PostgreSQL database
    3. Authentication
    4. REST API
    5. Django or FastAPI backend
    6. Redis
    7. Background worker
    8. Message queue
    9. Docker
    10. Automated tests
    11. GitHub Actions
    12. Production deployment
    13. Domain + HTTPS
    14. Logging
    15. Monitoring
    16. Backups
    17. Documentation
    18. Production debugging
    19. Performance optimization