Goal: Become interview-ready and production-capable for SDE, Backend Engineer, AI Engineer, GenAI Engineer, and AI/Backend Engineer fresher roles.
For every important concept, reach these levels:
-
L1 — Understand: I can explain what it is.
-
L2 — Implement: I can code/use it without following a tutorial.
-
L3 — Internals: I understand what happens underneath.
-
L4 — Interview: I can answer follow-up questions and solve problems involving it.
-
L5 — Production: I understand its trade-offs, failure modes, scaling and security implications.
A major topic is DONE only when I can:
Explain → Implement → Debug → Optimize → Discuss Trade-offs-
Variables and data types
-
Stack vs heap
-
Pointers
-
References
-
Memory allocation
-
Arrays
-
Strings
-
Functions
-
Recursion
-
Scope
-
Lifetime
-
Pass by value
-
Pass by reference
-
Const correctness
-
Error handling
-
Time complexity
-
Space complexity
-
STL overview
-
vector
-
string
-
pair
-
tuple
-
stack
-
queue
-
deque
-
priority_queue
-
set
-
unordered_set
-
map
-
unordered_map
-
Iterators
-
Algorithms
-
Lambda functions
-
References
-
Move semantics
-
Smart pointers
-
RAII
-
Rule of 3
-
Rule of 5
-
Rule of 0
-
Python syntax
-
List / tuple / set / dict
-
Comprehensions
-
Functions
-
*args / **kwargs
-
Lambda
-
Iterators
-
Generators
-
Decorators
-
Context managers
-
Exceptions
-
Modules
-
Packages
-
Virtual environments
-
Type hints
-
Dataclasses
-
Pydantic
-
Python memory model
-
Garbage collection
-
GIL
-
multiprocessing
-
threading
-
asyncio
-
Class
-
Object
-
Constructor
-
Destructor
-
Encapsulation
-
Abstraction
-
Inheritance
-
Polymorphism
-
Function overloading
-
Function overriding
-
Virtual functions
-
Pure virtual functions
-
Abstract classes
-
Interfaces
-
Static members
-
Friend functions
-
Multiple inheritance
-
Diamond problem
-
Composition
-
Aggregation
-
Association
-
Dependency
-
SOLID
-
Single Responsibility
-
Open/Closed
-
Liskov Substitution
-
Interface Segregation
-
Dependency Inversion
-
Composition over inheritance
-
Singleton
-
Factory
-
Abstract Factory
-
Builder
-
Strategy
-
Observer
-
Adapter
-
Decorator
-
Repository
-
Dependency Injection
Highest-priority SDE interview section.
-
Big-O
-
Big-Theta
-
Big-Omega
-
Amortized analysis
-
Best / average / worst case
-
Recurrence relations
-
Master theorem
-
Traversal
-
Insertion / deletion
-
Prefix sum
-
Difference array
-
Frequency counting
-
Kadane’s algorithm
-
Sorting
-
In-place algorithms
-
Matrix traversal
-
Rotations
-
Two pointers
-
Sliding window
-
Prefix sum
-
Hashing
-
Binary search
-
Two Sum
-
Best Time to Buy/Sell Stock
-
Maximum Subarray
-
Product Except Self
-
3Sum
-
Container With Most Water
-
Subarray Sum Equals K
-
Merge Intervals
-
Insert Interval
-
Character frequency
-
Anagrams
-
Palindromes
-
Substrings
-
String hashing
-
String manipulation
-
Sliding window on strings
-
Pattern matching
-
KMP
-
Rabin-Karp
-
Z algorithm
-
Singly linked list
-
Doubly linked list
-
Circular linked list
-
Reverse linked list
-
Fast/slow pointers
-
Cycle detection
-
Merge lists
-
Intersection
-
Reordering
-
LRU cache implementation
-
Reverse Linked List
-
Merge Two Sorted Lists
-
Linked List Cycle
-
Remove Nth Node
-
Reorder List
-
Merge K Sorted Lists
-
Stack
-
Queue
-
Deque
-
Monotonic stack
-
Monotonic queue
-
Min stack
-
Expression evaluation
-
Infix / postfix / prefix
-
Valid Parentheses
-
Min Stack
-
Daily Temperatures
-
Largest Rectangle in Histogram
-
Sliding Window Maximum
-
Standard binary search
-
Lower bound
-
Upper bound
-
Search on answer
-
Rotated arrays
-
Binary search on 2D data
-
Binary Search
-
Search Rotated Sorted Array
-
Find Minimum Rotated Array
-
Koko Eating Bananas
-
Median of Two Sorted Arrays
-
Binary tree
-
Tree terminology
-
DFS
-
BFS
-
Preorder
-
Inorder
-
Postorder
-
Level order
-
Height / depth
-
Diameter
-
Balanced tree
-
Path problems
-
Lowest Common Ancestor
-
BST properties
-
Search
-
Insert
-
Delete
-
Validation
-
Successor / predecessor
-
Heap
-
Min heap
-
Max heap
-
Trie
-
Segment tree
-
Fenwick tree
-
Maximum Depth
-
Invert Binary Tree
-
Diameter
-
Level Order Traversal
-
Validate BST
-
Kth Smallest BST
-
Lowest Common Ancestor
-
Serialize / Deserialize
-
Graph terminology
-
Adjacency matrix
-
Adjacency list
-
BFS
-
DFS
-
Visited arrays
-
Connected components
-
Cycle detection
-
Bipartite graphs
-
Topological sorting
-
DAG
-
Shortest path
-
Minimum spanning tree
-
BFS shortest path
-
Dijkstra
-
Bellman-Ford
-
Floyd-Warshall
-
Kruskal
-
Prim
-
Union-Find / DSU
-
Kahn’s algorithm
-
Number of Islands
-
Clone Graph
-
Course Schedule
-
Rotting Oranges
-
Pacific Atlantic Water Flow
-
Network Delay Time
-
Graph Valid Tree
-
Greedy principle
-
Activity selection
-
Interval scheduling
-
Fractional knapsack
-
Jump Game
-
Gas Station
-
Huffman coding
-
Recursion
-
Overlapping subproblems
-
Optimal substructure
-
Memoization
-
Tabulation
-
Space optimization
-
1D DP
-
2D DP
-
Grid DP
-
Knapsack
-
Subset sum
-
Partition
-
LCS
-
LIS
-
Interval DP
-
State-machine DP
-
Climbing Stairs
-
House Robber
-
Coin Change
-
Word Break
-
Longest Increasing Subsequence
-
Longest Common Subsequence
-
0/1 Knapsack
-
Partition Equal Subset Sum
-
Database vs DBMS
-
Relational databases
-
Tables
-
Rows
-
Columns
-
Primary keys
-
Foreign keys
-
Candidate keys
-
Composite keys
-
Constraints
-
Functional dependency
-
1NF
-
2NF
-
3NF
-
BCNF
-
Denormalization
-
Normalization trade-offs
-
Transaction
-
ACID
-
Atomicity
-
Consistency
-
Isolation
-
Durability
-
Dirty read
-
Non-repeatable read
-
Phantom read
-
Lost update
-
Isolation levels
-
Locks
-
Shared lock
-
Exclusive lock
-
MVCC
-
Deadlocks
-
What is an index?
-
Why indexes improve reads
-
B-Tree
-
B+ Tree
-
Hash indexes
-
Composite indexes
-
Covering indexes
-
Index selectivity
-
Query planner
-
EXPLAIN
-
When indexes hurt performance
-
Replication
-
Sharding
-
Partitioning
-
Read replicas
-
Connection pooling
-
CAP theorem
-
Eventual consistency
-
SELECT
-
WHERE
-
ORDER BY
-
GROUP BY
-
HAVING
-
DISTINCT
-
LIMIT
-
CASE
-
NULL handling
-
COALESCE
-
INNER JOIN
-
LEFT JOIN
-
RIGHT JOIN
-
FULL JOIN
-
CROSS JOIN
-
SELF JOIN
-
Subqueries
-
Correlated subqueries
-
CTE
-
Recursive CTE
-
Window functions
-
ROW_NUMBER
-
RANK
-
DENSE_RANK
-
LEAD
-
LAG
-
PARTITION BY
-
Running totals
-
Conditional aggregation
-
Second highest salary
-
Nth highest salary
-
Duplicate records
-
Employees above average
-
Highest salary per department
-
Second highest salary per department
-
Top N per group
-
Consecutive records
-
Running total
-
Customers with no orders
-
Employee-manager relationship
-
Duplicate removal
-
Gaps and islands
-
Program vs process
-
Process states
-
PCB
-
Context switching
-
Process scheduling
-
Threads
-
User vs kernel threads
-
Process vs thread
-
Concurrency vs parallelism
-
FCFS
-
SJF
-
SRTF
-
Round Robin
-
Priority scheduling
-
Multilevel queues
-
Race condition
-
Critical section
-
Mutex
-
Semaphore
-
Monitor
-
Producer-consumer
-
Reader-writer
-
Dining philosophers
-
Deadlock
-
Four necessary conditions
-
Deadlock prevention
-
Deadlock avoidance
-
Banker’s algorithm
-
Deadlock detection
-
Stack
-
Heap
-
Virtual memory
-
Paging
-
Segmentation
-
Page table
-
TLB
-
Page fault
-
Demand paging
-
Page replacement
-
FIFO
-
LRU
-
Optimal replacement
-
Files
-
Directories
-
Inodes
-
File descriptors
-
Permissions
-
System calls
-
OSI model
-
TCP/IP model
-
MAC address
-
IP address
-
IPv4
-
IPv6
-
Subnetting
-
Ports
-
Sockets
-
HTTP
-
HTTPS
-
TCP
-
UDP
-
DNS
-
DHCP
-
ARP
-
ICMP
-
Three-way handshake
-
Four-way termination
-
Sequence numbers
-
ACK
-
Retransmission
-
Flow control
-
Congestion control
-
Slow start
-
HTTP methods
-
HTTP status codes
-
Headers
-
Cookies
-
Sessions
-
Caching
-
CORS
-
WebSockets
-
SSE
-
TLS
-
Certificates
-
Encryption
-
Symmetric encryption
-
Asymmetric encryption
-
Hashing
-
What happens when entering a URL?
-
How DNS works
-
TCP vs UDP
-
HTTP vs HTTPS
-
TLS handshake
-
How WebSockets work
-
REST
-
REST principles
-
HTTP methods
-
Idempotency
-
Status codes
-
Headers
-
Query parameters
-
Path parameters
-
Request body
-
Pagination
-
Filtering
-
Sorting
-
API versioning
-
Authentication vs authorization
-
Sessions
-
Cookies
-
JWT
-
Access tokens
-
Refresh tokens
-
OAuth2
-
RBAC
-
Password hashing
-
Input validation
-
SQL injection
-
XSS
-
CSRF
-
CORS
-
Rate limiting
-
Brute-force protection
-
Secrets management
-
TLS
-
MVC
-
Layered architecture
-
Service layer
-
Repository pattern
-
Dependency injection
-
Clean architecture
-
SOLID in backend
-
Application setup
-
Routing
-
APIRouter
-
Path parameters
-
Query parameters
-
Request bodies
-
Pydantic
-
Response models
-
Validation
-
Dependency injection
-
Middleware
-
Exception handling
-
Authentication
-
JWT
-
OAuth2
-
Background tasks
-
Async endpoints
-
Streaming responses
-
WebSockets
-
OpenAPI
-
Swagger
-
Testing
-
Project structure
-
Production deployment
-
Event loop
-
Coroutine
-
await
-
async
-
Tasks
-
Concurrent I/O
-
Blocking vs non-blocking
-
Async DB drivers
-
Thread pool
-
When NOT to use async
-
Django architecture
-
Models
-
Views
-
URLs
-
Templates
-
ORM
-
QuerySets
-
Migrations
-
Serializers
-
ViewSets
-
Routers
-
Authentication
-
Permissions
-
Middleware
-
Signals
-
Pagination
-
Filtering
-
Caching
-
Transactions
-
Testing
-
Production deployment
-
Tables
-
Constraints
-
Relationships
-
Joins
-
Transactions
-
Indexes
-
EXPLAIN
-
EXPLAIN ANALYZE
-
Query optimization
-
CTEs
-
Window functions
-
JSON/JSONB
-
Full-text search
-
Extensions
-
Connection pooling
-
Replication
-
Backup / restore
-
What Redis is
-
In-memory architecture
-
Key-value model
-
Strings
-
Lists
-
Sets
-
Sorted sets
-
Hashes
-
TTL
-
Cache-aside
-
Write-through cache
-
Write-behind cache
-
Cache invalidation
-
Distributed locks
-
Rate limiting
-
Pub/Sub
-
Streams
-
Why queues exist
-
Producer
-
Consumer
-
Message broker
-
RabbitMQ
-
Kafka fundamentals
-
Celery
-
Task queues
-
Retries
-
Dead-letter queues
-
Idempotency
-
At-least-once delivery
-
At-most-once delivery
-
Exactly-once semantics
-
Async processing
-
Containers
-
Images
-
Dockerfile
-
Layers
-
Volumes
-
Networks
-
Environment variables
-
Docker Compose
-
Multi-stage builds
-
Container security
-
Processes
-
Signals
-
Permissions
-
File system
-
Environment variables
-
SSH
-
grep
-
awk
-
sed
-
curl
-
systemctl
-
journalctl
-
networking commands
-
GitHub Actions
-
Build pipeline
-
Tests
-
Linting
-
Docker build
-
Deployment
-
Secrets
-
Rollbacks
-
init
-
clone
-
add
-
commit
-
push
-
pull
-
branch
-
merge
-
rebase
-
cherry-pick
-
stash
-
reset
-
revert
-
reflog
-
merge conflicts
-
.gitignore
-
GitHub PR workflow
-
Scalability
-
Availability
-
Reliability
-
Latency
-
Throughput
-
Fault tolerance
-
Horizontal scaling
-
Vertical scaling
-
Stateless services
-
Load balancing
-
Load balancer
-
Reverse proxy
-
API gateway
-
Cache
-
Database
-
Read replica
-
Message queue
-
Object storage
-
CDN
-
Search engine
-
CAP theorem
-
Consistency
-
Availability
-
Partition tolerance
-
Strong consistency
-
Eventual consistency
-
Replication
-
Sharding
-
Leader/follower
-
Consensus basics
-
Retry
-
Exponential backoff
-
Timeout
-
Circuit breaker
-
Rate limiter
-
Bulkhead
-
Idempotency
-
Graceful degradation
-
URL Shortener
-
Rate Limiter
-
Chat Application
-
Notification System
-
File Storage
-
Instagram Feed
-
YouTube-like system
-
Ride-sharing system
-
Job Queue
-
Vectors
-
Matrices
-
Matrix multiplication
-
Dot product
-
Eigenvalues
-
Eigenvectors
-
Probability
-
Conditional probability
-
Bayes theorem
-
Mean
-
Variance
-
Standard deviation
-
Distributions
-
Derivatives
-
Partial derivatives
-
Gradients
-
Supervised learning
-
Unsupervised learning
-
Semi-supervised learning
-
Regression
-
Classification
-
Clustering
-
Feature engineering
-
Training
-
Validation
-
Testing
-
Linear regression
-
Logistic regression
-
KNN
-
Naive Bayes
-
Decision trees
-
Random forest
-
Gradient boosting
-
XGBoost
-
SVM
-
K-Means
-
PCA
-
Overfitting
-
Underfitting
-
Bias
-
Variance
-
Regularization
-
Data leakage
-
Class imbalance
-
Feature scaling
-
Cross-validation
-
Accuracy
-
Precision
-
Recall
-
F1
-
Confusion matrix
-
ROC-AUC
-
PR-AUC
-
MAE
-
MSE
-
RMSE
-
R²
-
Neuron
-
Weights
-
Bias
-
Activation functions
-
Forward propagation
-
Loss function
-
Backpropagation
-
Gradient descent
-
Sigmoid
-
Tanh
-
ReLU
-
Leaky ReLU
-
Softmax
-
GELU
-
Batch
-
Epoch
-
Learning rate
-
Batch size
-
Optimizer
-
SGD
-
Momentum
-
Adam
-
AdamW
-
Weight decay
-
Learning rate scheduling
-
Early stopping
-
CNN
-
RNN
-
LSTM
-
GRU
-
Autoencoder
-
GAN
-
Diffusion models
Critical AI Engineer topic.
-
Tokenization
-
Vocabulary
-
Token IDs
-
Embeddings
-
Positional encoding
-
Self-attention
-
Query
-
Key
-
Value
-
Attention scores
-
Scaled dot-product attention
-
Multi-head attention
-
Feed-forward network
-
Residual connections
-
Layer normalization
-
Transformer encoder
-
Transformer decoder
-
Encoder-decoder architecture
-
Causal masking
-
Cross-attention
Attention(Q,K,V)
=
softmax(QKᵀ / √dₖ)V-
Explain Q
-
Explain K
-
Explain V
-
Explain scaling
-
Explain softmax
-
Explain masking
-
Explain multi-head attention
-
Text preprocessing
-
Tokenization
-
Stemming
-
Lemmatization
-
Word embeddings
-
Word2Vec
-
GloVe
-
Contextual embeddings
-
Sequence modeling
-
Attention
-
Transformers
-
LLM architecture
-
Parameters
-
Weights
-
Tokens
-
Context window
-
Vocabulary
-
Logits
-
Probability distribution
-
Next-token prediction
-
Pretraining
-
Dataset construction
-
Data cleaning
-
Tokenization
-
Pretraining objective
-
Instruction tuning
-
Fine-tuning
-
RLHF
-
Preference optimization
-
Temperature
-
Top-K
-
Top-P
-
Greedy decoding
-
Beam search
-
Sampling
-
KV cache
-
Batching
-
Streaming
-
Hallucination
-
Context limitations
-
Bias
-
Prompt injection
-
Jailbreaking
-
Data leakage
-
Cost
-
Latency
-
What embeddings represent
-
Sentence embeddings
-
Document embeddings
-
Query embeddings
-
Embedding dimensions
-
Semantic similarity
-
Cosine similarity
-
Euclidean distance
-
Dot product
-
Normalization
-
Embedding model selection
-
Multilingual embeddings
-
Why vector databases exist
-
Vector storage
-
Similarity search
-
Approximate nearest neighbor
-
Exact nearest neighbor
-
HNSW
-
IVF
-
Product quantization
-
Metadata filtering
-
Hybrid search
-
Index configuration
-
Recall vs latency trade-off
Learn at least one deeply:
-
pgvector
-
Qdrant
-
Weaviate
-
Pinecone
-
Milvus
Primary specialization.
-
Document ingestion
-
Document parsing
-
Cleaning
-
Chunking
-
Embedding
-
Vector storage
-
Retrieval
-
Context construction
-
Prompt construction
-
Generation
-
Fixed-size chunking
-
Recursive chunking
-
Sentence chunking
-
Semantic chunking
-
Document-aware chunking
-
Chunk overlap
-
Chunk-size trade-offs
-
Dense retrieval
-
Sparse retrieval
-
BM25
-
Hybrid retrieval
-
Top-K
-
Metadata filtering
-
Similarity thresholds
-
Query rewriting
-
Query expansion
-
Multi-query retrieval
-
HyDE
-
Parent-child retrieval
-
Contextual retrieval
-
Reranking
-
Cross-encoder reranker
-
Corrective RAG
-
Agentic RAG
-
Graph RAG
-
Bad chunking
-
Wrong retrieval
-
Missing context
-
Too much context
-
Irrelevant context
-
Lost-in-the-middle
-
Hallucination
-
Stale documents
-
Duplicate documents
Must know for serious AI engineering.
-
Recall@K
-
Precision@K
-
MRR
-
NDCG
-
Hit rate
-
Faithfulness
-
Answer relevance
-
Context relevance
-
Groundedness
-
Citation correctness
-
Create evaluation dataset
-
Define ground truth
-
Offline evaluation
-
Online evaluation
-
Regression testing
-
A/B testing
-
Human evaluation
-
LLM-as-judge
-
Error analysis
-
System prompts
-
User prompts
-
Role prompting
-
Few-shot prompting
-
Zero-shot prompting
-
Chain-of-thought concepts
-
Structured outputs
-
JSON outputs
-
Prompt templates
-
Prompt versioning
-
Prompt injection defense
-
Context management
-
Agent definition
-
Agent vs workflow
-
Planning
-
Reasoning
-
Tool use
-
Memory
-
Observation
-
Action
-
Agent loop
-
Function calling
-
Tool schemas
-
Tool selection
-
Tool execution
-
Tool validation
-
Tool errors
-
Retries
-
Timeouts
-
ReAct
-
Planning agents
-
Reflection
-
Multi-agent systems
-
Human-in-the-loop
-
Long-term memory
-
Agent evaluation
-
Agent security
Learn concepts first; frameworks second.
-
Transformers
-
Tokenizers
-
Model loading
-
Pipelines
-
Datasets
-
Model Hub
-
Models
-
Prompts
-
Retrievers
-
Chains
-
Tools
-
Agents
-
Memory
-
LCEL concepts
-
Document ingestion
-
Nodes
-
Indexes
-
Retrievers
-
Query engines
-
Agents
-
Ollama
-
Model formats
-
Quantization basics
-
Local inference
-
GPU vs CPU inference
-
Quantization
-
INT8
-
INT4
-
FP16
-
BF16
-
KV cache
-
Batching
-
Continuous batching
-
Speculative decoding
-
Distillation
-
Pruning
-
LoRA
-
QLoRA
-
PEFT
-
Fine-tuning vs RAG
-
When to fine-tune
-
Dataset preparation
-
Instruction dataset
-
Training/validation split
-
LoRA
-
QLoRA
-
PEFT
-
Hyperparameters
-
Evaluation
-
Catastrophic forgetting
-
Overfitting
-
Model loading
-
Inference
-
GPU memory
-
VRAM requirements
-
Batching
-
Streaming
-
Token throughput
-
Time to first token
-
Tokens/sec
-
Latency
-
Concurrency
-
vLLM
-
Hugging Face TGI concepts
-
Ollama
-
ONNX Runtime
-
TensorRT concepts
text SDE CORE [ ] 0% DSA [ ] 0% DBMS/SQL [ ] 0% OS [ ] 0% CN [ ] 0% BACKEND [ ] 0% SYSTEM DESIGN [ ] 0%
ML [ ] 0% DEEP LEARNING [ ] 0% TRANSFORMERS [ ] 0% LLM [ ] 0% RAG [ ] 0% AI AGENTS [ ] 0% AI ENGINEERING [ ] 0%
PROJECTS [ ] 0% INTERVIEWS [ ] 0%
SDE / Backend / AI Engineer / GenAI Engineer 
Be able to design:
Client
↓
API Gateway
↓
FastAPI
↓
Authentication
↓
Service Layer
├── PostgreSQL
├── Redis
├── Celery
└── AI Service
├── Embedding Model
├── Vector DB
├── Reranker
└── LLMUnderstand:
-
Request flow
-
Async processing
-
Streaming
-
Caching
-
Rate limiting
-
Authentication
-
Authorization
-
Observability Progress
text SDE CORE [ ] 0% DSA [ ] 0% DBMS/SQL [ ] 0% OS [ ] 0% CN [ ] 0% BACKEND [ ] 0% SYSTEM DESIGN [ ] 0%
ML [ ] 0% DEEP LEARNING [ ] 0% TRANSFORMERS [ ] 0% LLM [ ] 0% RAG [ ] 0% AI AGENTS [ ] 0% AI ENGINEERING [ ] 0%
PROJECTS [ ] 0% INTERVIEWS [ ] 0%
SDE / Backend / AI Engineer / GenAI Engineer 
-
Failure recovery
-
Cost optimization
-
Latency optimization
-
Horizontal scaling
-
Prompt injection
-
Indirect prompt injection
-
Jailbreaking
-
Data exfiltration
-
Sensitive data leakage
-
RAG poisoning
-
Malicious documents
-
Unsafe tool calls
-
Excessive agent permissions
-
Output validation
-
Input validation
-
Sandboxing
-
Rate limiting
-
Authentication
-
Authorization
-
Secret management
-
Logging
-
Metrics
-
Tracing
-
Request IDs
-
Token usage
-
Latency tracking
-
Cost tracking
-
Retrieval debugging
-
Prompt tracing
-
Model monitoring
-
Error monitoring
Know what to measure:
TTFT
Tokens/sec
Total latency
Prompt tokens
Completion tokens
Cost/request
Retrieval latency
Retrieval quality
Answer quality
Error rate-
Unit testing
-
Integration testing
-
End-to-end testing
-
Mocking
-
Fixtures
-
Test coverage
-
API tests
-
Authentication tests
-
Database tests
-
Failure tests
-
Load testing
-
Prompt tests
-
Retrieval tests
-
RAG evaluation
-
Regression tests
-
Hallucination tests
-
Safety tests
-
Adversarial tests
-
Compute
-
Storage
-
Networking
-
IAM
-
Databases
-
Containers
-
Serverless
-
Load balancing
-
Monitoring
-
EC2
-
S3
-
RDS
-
Lambda
-
VPC
-
IAM
-
CloudWatch
-
ECS/EKS concepts
-
Authentication
-
Authorization
-
RBAC
-
REST APIs
-
PostgreSQL
-
Redis
-
Background jobs
-
Pagination
-
Filtering
-
Validation
-
Logging
-
Error handling
-
Tests
-
Docker
-
CI/CD
-
Deployment
-
Documentation
-
Architecture diagram
-
Document upload
-
Document parsing
-
Chunking
-
Embeddings
-
Vector DB
-
Hybrid retrieval
-
Reranking
-
LLM
-
Streaming
-
Citations
-
Authentication
-
Document-level permissions
-
Conversation history
-
Redis caching
-
Evaluation dataset
-
RAG metrics
-
Prompt injection protection
-
Observability
-
Docker
-
Deployment
-
Planner
-
LLM
-
Tool calling
-
Search
-
RAG
-
Memory
-
Multi-step execution
-
Retry handling
-
Human approval
-
Structured output
-
Citation generation
-
Evaluation
-
Security
-
FastAPI
-
Redis
-
Celery
-
PostgreSQL
-
Docker
-
Deployment
-
100 easy problems
-
100 medium problems
-
20 hard problems
-
Blind 75
-
NeetCode-style pattern revision
-
Timed contests
-
Re-solve failed problems
-
50 basic queries
-
50 intermediate queries
-
30 advanced queries
-
Window functions
-
CTE
-
Complex joins
-
Gaps & islands
-
50 OOP questions
-
50 DBMS questions
-
50 OS questions
-
50 CN questions
-
REST
-
Authentication
-
JWT
-
Django
-
FastAPI
-
PostgreSQL
-
Redis
-
Celery
-
Docker
-
API design
-
50 ML questions
-
50 DL questions
-
50 LLM questions
-
50 RAG questions
-
30 AI system-design questions
-
20 AI debugging scenarios
For every project, be able to answer:
-
What problem does it solve?
-
Why did you build it?
-
Why these technologies?
-
Explain the architecture.
-
Explain the database schema.
-
Explain the API flow.
-
Explain authentication.
-
Explain authorization.
-
Biggest technical challenge?
-
Biggest bug?
-
Biggest performance bottleneck?
-
How did you debug it?
-
What would you change?
-
How would you scale it?
-
How would you secure it?
-
What happens if a service fails?
-
What happens under 10× traffic?
-
What happens under 100× traffic?
-
Why RAG?
-
Why not fine-tuning?
-
Why this embedding model?
-
Why this vector DB?
-
Why this chunk size?
-
How is retrieval performed?
-
Why Top-K?
-
Why reranking?
-
How did you evaluate it?
-
How did you reduce hallucination?
-
How did you handle prompt injection?
-
How did you reduce latency?
-
How did you reduce cost?
-
How would you scale inference?
Design these from scratch:
-
URL Shortener
-
Rate Limiter
-
Pastebin
-
Chat Application
-
Notification Service
-
File Storage
-
Video Streaming
-
Social Media Feed
-
Search System
-
Ride Sharing
-
Food Delivery
-
Job Queue
-
Distributed Cache
-
AI Chatbot
-
RAG System
-
AI Agent Platform
-
LLM Gateway
For every design:
Requirements
↓
API design
↓
Data model
↓
Architecture
↓
Database
↓
Caching
↓
Scaling
↓
Failure handling
↓
Security
↓
Monitoring
↓
Trade-offs-
DSA
-
OOP
-
DBMS
-
SQL
-
OS
-
CN
-
Backend
-
APIs
-
Authentication
-
PostgreSQL
-
Redis
-
Queues
-
Docker
-
Git
-
System Design
-
Testing
-
Security
-
Mathematics
-
ML
-
Deep Learning
-
NLP
-
Transformers
-
LLMs
-
Embeddings
-
Vector DB
-
RAG
-
RAG Evaluation
-
Prompt Engineering
-
Agents
-
Tool Calling
-
Fine-tuning
-
LoRA / QLoRA
-
Quantization
-
LLM Serving
-
AI Security
-
AI Observability
-
AI System Design
-
Linux
-
Docker
-
CI/CD
-
Cloud
-
Monitoring
-
Logging
-
Testing
-
Distributed Systems
-
Production backend project
-
Production RAG project
-
Agentic AI project
-
All projects deployed
-
All projects documented
-
Architecture diagrams
-
GitHub repositories cleaned
-
Strong README
-
Resume updated
-
LinkedIn updated
-
Mock interviews
-
DSA timed practice
-
SQL timed practice
-
CS fundamentals revision
Don’t chase technologies.
Build this progression:
FUNDAMENTALS
│
┌──────────────┴──────────────┐
│ │
SDE AI
│ │
DSA / DBMS / OS ML / DL / NLP
CN / OOP / SQL │
│ Transformers
│ │
Backend LLM
│ │
APIs / DB / Redis RAG
│ │
Docker / Cloud Agents
│ │
└──────────────┬──────────────┘
│
SYSTEM DESIGN
│
PRODUCTION
│
INTERVIEWS
│
▼
AI-BACKEND ENGINEERI am job ready when I can:
-
Solve a medium DSA problem in ~30 minutes.
-
Write complex SQL without assistance.
-
Explain OS/DBMS/CN/OOP fundamentals clearly.
-
Build a REST API from scratch.
-
Design authentication and authorization.
-
Design a PostgreSQL schema.
-
Debug backend failures.
-
Dockerize an application.
-
Deploy an application.
-
Design a scalable backend.
-
Explain Transformers from first principles.
-
Explain how an LLM generates a response.
-
Build RAG without blindly relying on a framework.
-
Diagnose poor RAG retrieval.
-
Evaluate RAG quantitatively.
-
Build an agent with tools.
-
Explain RAG vs fine-tuning.
-
Explain LLM latency/cost optimization.
-
Design an AI system end-to-end.
-
Defend every technology choice in my projects.
-
Complete a technical interview without relying on memorized scripts.
When time is limited:
DSA
SQL
DBMS
OOP
OS
CN
Backend
FastAPI/Django
PostgreSQL
REST
System Design
ML fundamentals
Transformers
LLMs
Embeddings
RAG
RAG Evaluation
AI Security
ProjectsRedis
Celery
Docker
Kafka
Cloud
Agents
Fine-tuning
LoRA
Quantization
LLM serving
Observability
Distributed systemsKubernetes
Ray
Advanced distributed systems
Advanced GPU optimization
Advanced model architecture research
Exotic AI frameworksEvery study day:
-
1–3 DSA problems
-
1 SQL problem
-
1 CS concept
-
1 backend concept
-
1 AI concept
-
Revise yesterday’s mistakes
-
Write down one new interview question
-
Explain one concept without notes
-
Code something without AI assistance
-
Re-solve failed DSA problems
-
Review SQL mistakes
-
Review CS notes
-
Review project architecture
-
Build something
-
Do one timed DSA session
-
Do one mock interview
-
Update this checklist
Use AI as:
Teacher
Debugger
Interviewer
Code reviewer
Architecture reviewerNot as:
Answer generatorBefore asking AI for a solution:
-
Think independently
-
Attempt implementation
-
Identify where stuck
-
Ask for a hint
-
Implement yourself
-
Compare approaches
-
Re-solve later without AI