Learning Paths
Select a learning path that matches your goals. Each path is designed to build knowledge progressively.
Beginner Path — Data Structures & Algorithms
Duration: 8-10 weeks | Prerequisites: Basic programming knowledge
Perfect for those new to data structures and algorithms.
Week 1-2: Foundations
- Big O Notation - Understand algorithm efficiency
- Time Complexity - Analyze execution time
- Space Complexity - Analyze memory usage
Week 3-4: Arrays & Strings
- Arrays Introduction - Basic operations
- Two Pointers - Essential technique
- Sliding Window - Subarray problems
- Strings - Text manipulation
Week 5-6: Linear Data Structures
- Linked Lists - Node-based storage
- Stacks - LIFO operations
- Queues - FIFO operations
- Hash Tables - Key-value storage
Week 7-8: Trees & Basic Algorithms
- Trees Introduction - Hierarchical data
- Sorting Algorithms - Basic sorts
- Binary Search
Week 9-10: Recursion & Graphs
- Recursion - Recursive thinking
- Graphs Introduction - Networks and connections
Software Engineering Fundamentals Path
Duration: 10-12 weeks | Prerequisites: Basic programming knowledge
Build a solid foundation in core software engineering concepts beyond algorithms.
Week 1-2: Object-Oriented Programming
- OOP & SOLID Overview - Why OOP matters
- Four Pillars of OOP - Encapsulation, Abstraction, Inheritance, Polymorphism
- SOLID Principles - Writing maintainable code
- Composition vs Inheritance - When to use each
- Design Smells - Recognizing and fixing bad code
Week 3-4: Version Control & Testing
- Version Control Overview - Why version control matters
- Git Fundamentals - Essential commands
- Branching Strategies - Git Flow, GitHub Flow, Trunk-Based
- Code Review - Review best practices
- Testing Overview - Testing pyramid and principles
- Unit Testing - Writing effective unit tests
Week 5-6: Operating Systems & Concurrency
- Operating Systems Overview - Core OS concepts
- Processes & Threads - Process management
- CPU Scheduling - Scheduling algorithms
- Memory Management - Virtual memory and paging
- Concurrency Overview - Threads vs parallelism
- Threads & Synchronization - Mutexes, semaphores, locks
Week 7-8: Computer Networks & Databases
- Computer Networks Overview - How the internet works
- OSI Model & TCP/IP - Protocol layers
- HTTP & HTTPS - Web protocols
- Database Engineering Overview - SQL vs NoSQL
- SQL Fundamentals - Queries, joins, aggregations
- Normalization & Schema Design - Efficient schema design
Week 9-10: Security & Software Design
- Security Overview - CIA triad, threat modeling
- OWASP Top 10 - Common vulnerabilities
- Secure Coding - Writing safe code
- Design Patterns Overview - Common patterns
- Software Architecture Overview - Architectural styles
Week 11-12: Engineering Practices
- API Design Overview - REST, GraphQL, gRPC
- REST APIs - RESTful design
- SDLC & Agile Overview - Development methodologies
- DevOps Overview - CI/CD and deployment
- TDD & Mocking - Test-driven development
Interview Prep Path
Duration: 6-8 weeks | Prerequisites: Basic DSA knowledge
Focused preparation for technical interviews at top companies.
Week 1: Array & String Mastery
- Two Pointers pattern (15+ problems)
- Sliding Window pattern (10+ problems)
- Prefix Sum technique
- String manipulation problems
Target: 30 problems | Companies: Google, Amazon, Meta
Week 2: Linked Lists & Stacks
- Fast & Slow pointers
- Reversal techniques
- Monotonic Stack pattern
- Expression evaluation
Target: 20 problems | Companies: Microsoft, Apple
Week 3: Trees & Graphs
- Tree traversals (all types)
- BST operations
- BFS/DFS patterns
- Shortest path problems
Target: 25 problems | Companies: Google, Meta, Netflix
Week 4: Dynamic Programming
- 1D DP problems
- 2D DP problems
- Knapsack variations
- String DP
Target: 20 problems | Companies: All top companies
Week 5: System Design & Architecture
- System Design Fundamentals - Core concepts
- Scalability - Scaling patterns
- Microservices - Distributed systems
- Database Design - Data layer decisions
Target: 5 system design problems
Week 6: Mock Interviews & Breadth
- Behavioral Interviews - STAR method
- Coding interview simulation
- System design practice
- Problem Bank - Practice problems
Advanced Path — Deep Dives
Duration: 12+ weeks | Prerequisites: Solid DSA and SE fundamentals
Deep dive into advanced topics across the full stack.
Weeks 1-3: Advanced Algorithms
- Dynamic Programming - Advanced DP patterns
- Backtracking - Constraint satisfaction
- Greedy Algorithms - Optimization techniques
- Heaps - Priority queues and applications
Weeks 4-6: Software Architecture
- Clean Architecture - Hexagonal, Onion, Clean
- Microservices - Service decomposition
- Event-Driven Architecture - Event sourcing, CQRS
- Domain-Driven Design - Strategic and tactical patterns
Weeks 7-9: Advanced Infrastructure
- Async Programming - Event loops and coroutines
- Race Conditions & Deadlocks - Concurrency bugs
- Containers & Docker - Containerization
- Kubernetes - Orchestration
- Monitoring & IaC - Observability
Weeks 10-12: Advanced APIs & Data
- GraphQL - Flexible queries
- gRPC & Protocol Buffers - High-performance APIs
- Indexing & Performance - Query optimization
- Transactions & NoSQL - ACID, CAP, and beyond
- Auth & Encryption - OAuth, JWT, TLS
- Integration & E2E Testing - Full testing strategy
Infrastructure & Cloud Path
Duration: 8-10 weeks | Prerequisites: SE Fundamentals Path, basic networking knowledge
Master distributed systems, cloud architecture, messaging, caching, and data engineering.
Weeks 1-2: Distributed Systems
- Distributed Systems Overview - Why distributed systems matter
- CAP Theorem - Consistency, Availability, Partition Tolerance
- Replication & Partitioning - Data distribution strategies
- Consensus Algorithms - Raft, Paxos, leader election
- Distributed Transactions - 2PC, Saga pattern
Weeks 3-4: Cloud Architecture
- Cloud Architecture Overview - Cloud-native principles
- Service Models - IaaS, PaaS, SaaS, FaaS
- Serverless - Functions as a Service
- Cloud Patterns - Circuit breaker, bulkhead, retry
- Cost Optimization - FinOps and right-sizing
Weeks 5-6: Message Queues & Streaming
- Message Queues Overview - Async communication patterns
- Pub/Sub - Publish-subscribe messaging
- Apache Kafka - Distributed streaming platform
- RabbitMQ & AMQP - Traditional message brokers
- Event Sourcing & CQRS - Event-driven patterns
Weeks 7-8: Caching & Performance
- Caching & Performance Overview - Why caching matters
- Caching Strategies - Cache-aside, write-through, eviction
- CDN & Edge - Content delivery networks
- Profiling & Benchmarking - Performance measurement
- Connection Pooling - Resource management
Weeks 9-10: Data Engineering
- Data Engineering Overview - The data lifecycle
- ETL Pipelines - Extract, Transform, Load
- Data Warehousing - Star schema, OLAP
- Stream Processing - Real-time data processing
- Data Quality - Testing and monitoring data
Functional Programming Path
Duration: 3-4 weeks | Prerequisites: Basic programming knowledge
Learn the principles of functional programming for cleaner, more composable code.
Week 1: Foundations
- Functional Programming Overview - FP vs OOP paradigms
- Pure Functions & Side Effects - Referential transparency
Week 2: Higher-Order Functions
- Higher-Order Functions - Map, filter, reduce, closures, currying
Week 3: Advanced Concepts
- Monads & Functors - Maybe, Either, functional error handling
- Pattern Matching - Algebraic data types, exhaustive matching
SRE & Operations Path
Duration: 4-6 weeks | Prerequisites: Linux basics, networking fundamentals
Build production-readiness skills: observability, SRE, Linux, and security.
Weeks 1-2: Linux & CLI
- Linux & CLI Overview - Architecture, shells, essential commands
- Shell Scripting - Bash scripting fundamentals
- File System & Permissions - chmod, chown, ACLs
- Process Management - Signals, systemd, cron
- Networking & CLI Tools - curl, SSH, tmux
Weeks 3-4: Observability & SRE
- Observability & SRE Overview - Pillars of observability
- Logging & Metrics - Structured logging, Prometheus
- Distributed Tracing - OpenTelemetry, Jaeger
- Incident Response - On-call, postmortems
- SLOs & Error Budgets - Reliability targets
Weeks 5-6: Security & Cryptography
- Cryptography Overview - Encryption fundamentals
- Symmetric & Asymmetric Encryption - AES, RSA, ECDH
- Hashing & Digital Signatures - SHA-256, HMAC, bcrypt
- TLS & PKI - Certificates, CAs, TLS handshake
Web & Specialized Topics Path
Duration: 4-6 weeks | Prerequisites: Basic programming, HTML/CSS familiarity
Expand your skills with web fundamentals, regex, accessibility, AI/ML, and leadership.
Week 1: Web Fundamentals
- Web Fundamentals Overview - How the web works
- HTML & Semantic Markup - Accessible, structured HTML
- CSS & Layout - Flexbox, Grid, responsive design
- JavaScript & the DOM - Event handling, manipulation
- Browser Internals - Rendering pipeline, event loop
Week 2: Regex & Text Processing
- Regex & Text Processing Overview - Why regex matters
- Regex Syntax - Patterns, quantifiers, groups
- Advanced Regex - Lookahead, backreferences
- Text Processing Tools - sed, awk, jq
Week 3: Accessibility & i18n
- Accessibility & i18n Overview - Why accessibility matters
- WCAG & ARIA - Guidelines and landmark regions
- i18n Patterns - Unicode, locales, RTL support
- Accessibility Testing - Automated and manual testing
Week 4: AI/ML for Engineers
- AI/ML Overview - ML concepts for software engineers
- ML Fundamentals - Supervised, unsupervised, neural networks
- LLM & Prompt Engineering - Working with large language models
- RAG & Embeddings - Retrieval-augmented generation
- ML System Design - Production ML pipelines
Week 5-6: Tech Leadership
- Tech Leadership Overview - The leadership journey
- Team Dynamics - Building high-performing teams
- Technical Decisions - ADRs, trade-off analysis
- Engineering Culture - Culture, values, mentoring
How to Use These Paths
- Check off topics as you complete them
- Practice problems after each concept
- Review regularly - spaced repetition helps
- Time yourself on problems as you progress
- Track your progress using our built-in tracker
Customize Your Path
Not every path fits every learner. Feel free to:
- Skip topics you’re already comfortable with
- Spend more time on challenging areas
- Mix elements from different paths
- Create your own order based on your needs
Start with Big O Notation Begin your DSA journey with algorithm analysis
Start with OOP & SOLID Begin your SE journey with object-oriented design
Explore Distributed Systems Start the Infrastructure & Cloud path
Learn Linux & CLI Start the SRE & Operations path