Software Engineer
The core path from fundamentals to production-ready engineering. Covers programming, data structures, databases, system design, and deployment.
Programming Fundamentals
Build the foundation — variables, control flow, functions, and core language concepts.
Understanding how programs store and manage data
How programs make decisions and repeat actions
Organizing code into reusable, composable units
Where variables live and how they're accessed
Working with text: manipulation, searching, and formatting
Ordered collections of data and how to work with them
Key-value data structures for modeling real-world entities
Advanced patterns for processing collections efficiently
Catching and recovering from errors gracefully
Blueprints for creating objects with shared behavior
Organizing code into reusable, shareable files
Recursion & Async
Think recursively and write non-blocking code.
Git & Version Control
Track changes, collaborate with others, and ship code using Git and GitHub.
Understanding how Git tracks and records changes to your code
Creating parallel lines of development and combining them back together
Synchronizing your local Git repository with servers and collaborators
A lightweight branching workflow for collaboration and continuous delivery
Reshaping commit history with rebase, cherry-pick, amend, and reset
Data Structures & Algorithms
Core data structures, sorting, searching, and complexity analysis.
Array operations, two-pointer techniques, and sliding window patterns
Fast key-value lookups using hash functions
Collections of unique values with fast membership testing
Dynamic data structures built from nodes and pointers
Last-In-First-Out data structure for tracking state
First-In-First-Out data structure for ordered processing
Hierarchical data structures with parent-child relationships
Organizing data efficiently with different sorting strategies
Finding elements efficiently with linear and binary search
How to measure and compare algorithm efficiency using Big O notation
Understanding memory usage of algorithms and data structures
Databases
Relational databases, indexing, transactions, and query optimization.
Organizing data into tables with rows and columns
Primary keys, foreign keys, and relationships between tables
Speeding up queries with B-tree and hash indexes
Ensuring data consistency with atomic operations
How databases optimize and execute your queries
Organizing data to reduce redundancy and improve integrity
System Design
Architecture patterns, scaling, and caching.
The fundamental pattern of modern networked applications
Separating concerns into presentation, business logic, and data layers
Storing computed results to avoid expensive recomputation
Growing your system by adding machines or upgrading existing ones
A single entry point that routes, authenticates, and rate-limits API requests
Production Engineering
Ship code confidently — CI/CD, containers, and observability.
Automated testing on every push and automated releases to production
Packaging applications into portable containers that run anywhere
Understanding what your application is doing in production through logs, metrics, and traces
Safely reverting bad deployments and responding to production incidents