Everything you need to go from zero to cracked in maths, DSA, systems, and software engineering. Follow the site top to bottom -- each section builds on the last. The order IS the roadmap.
Build the base. Math fundamentals, your first data structures, your tools, and your first language. Everything after this depends on nailing these. Go in order.
Numbers, BODMAS, fractions, decimals, percentages, ratios, exponents, and negative numbers.
Start HereVariables, equations, functions, polynomials, quadratics, logarithms, and exponent rules.
Phase 1Arithmetic and geometric progressions, sum formulas, n(n+1)/2, and why nested loops are O(n²).
Phase 1Shapes, angles, area, volume, trigonometry, coordinate geometry, and transformations.
Phase 1Binary, hex, octal, bitwise operations (AND, OR, XOR), bit manipulation, how data is stored as bytes, and C++ bitwise programming.
Phase 1What Linux is, the kernel and shell, directory structure, apt, Bash scripting, .bashrc, and ANSI terminal codes.
Phase 1Git internals, branches as pointers, the DAG, rebase, cherry-pick, reset vs revert, reflog, and GitHub CLI.
Phase 1V8 engine, execution context, closures, prototypes, the event loop, Proxy/Reflect, ES6+, modules, and memory management.
Phase 1Everything from zero: what data structures are, time complexity with the math, every core structure, algorithms, and a problem-solving framework.
Phase 1Array operations, two pointers, sliding window, prefix sum, and string manipulation.
Phase 1Hash map internals, frequency counting, Two Sum, Group Anagrams, and building from scratch.
Phase 1LIFO and FIFO structures, implementations, deques, and monotonic stack patterns.
Phase 1Singly and doubly linked lists, fast/slow pointers, reversal, and cycle detection.
Phase 12-3 Easy problems per day. Focus on Arrays, Strings, Hash Maps. Time yourself: 20 min per Easy. If stuck after 20 min, read the solution, understand it, then redo it tomorrow.
The real CS begins. Advanced math, trees, graphs, DP, and understanding how computers actually work at the OS and network level. This is where you go from beginner to competent.
Logic, sets, proofs, counting, graph theory, Big-O notation, and recurrence relations.
Phase 2Limits, derivatives, integrals, and their applications in CS and machine learning.
Phase 2Vectors, matrices, eigenvalues, transformations, and applications in ML and graphics.
Phase 2Probability rules, Bayes' theorem, distributions, statistics, and CS applications.
Phase 2Generics, conditional types, mapped types, utility types, infer, keyof, decorators, and tsconfig deep dive.
Phase 2Data types, pointers (single through triple indirection), RAII, smart pointers, vectors, strings, STL containers, and modern C++ features.
Phase 2Binary search trees, all traversals, DFS, BFS, and balanced tree concepts.
Phase 2BFS, DFS, Dijkstra's, topological sort, union-find, and cycle detection.
Phase 2All sorting algorithms, binary search variants, and built-in sorting pitfalls.
Phase 2Two pointers, sliding window, backtracking, prefix sum, greedy, sweep line, and the pattern cheat sheet.
Phase 2Top-down vs bottom-up, 1D and 2D DP, knapsack, LCS, and the 5-step framework.
Phase 2Heaps, tries, union-find, segment trees, bit manipulation, and math for interviews.
Phase 2Processes, syscalls, scheduling, threads, locks, virtual memory, paging, file systems, and security.
Phase 2OSI model, TCP/IP, DNS, HTTP/HTTPS, TLS, WebSockets, REST vs GraphQL vs gRPC, and socket programming.
Phase 2V8 + libuv architecture, event loop phases, streams, buffers, child_process, worker threads, and cluster.
Phase 2Binary data, buffers, streams, transactions, indexes, connection pooling, and database scaling.
Phase 2Setup, CLI, SQL fundamentals, joins, aggregation, database design, normalization, indexes, transactions, ACID, JSONB, connection from Node.js, and schema design exercises.
Phase 2650 curated LeetCode problems organized by topic. Start working through this during Phase 2.
Phase 22 Medium problems per day. Start the Blind 75 / NeetCode 150. Time yourself: 30 min per Medium. Do the problems in topic order (trees, then graphs, then DP). If you can't solve it in 30 min, study the solution and redo it next week.
This is where you become dangerous. Advanced math for CP, advanced algorithms that win contests, advanced data structures that solve impossible problems, and production infrastructure skills.
Fast exponentiation, Fermat's little theorem, extended Euclidean, Euler's totient, CRT, combinatorics (nCr mod p), Catalan numbers, matrix exponentiation, FFT, and Mobius inversion.
Phase 3KMP, Z-algorithm, Rabin-Karp hashing, edit distance (Levenshtein), suffix arrays, Aho-Corasick, Manacher's, string DP, and real-world applications like typing accuracy and fuzzy matching.
Phase 3MST (Kruskal/Prim), bridges and articulation points, SCCs (Tarjan/Kosaraju), LCA (binary lifting), max flow (Dinic's), bipartite matching, Euler paths, Floyd-Warshall, and 2-SAT.
Phase 3DP on trees, bitmask DP, digit DP, interval DP, SOS DP, convex hull trick, divide and conquer optimization, Knuth's optimization, and profile DP.
Phase 3Fenwick trees (BIT), segment trees with lazy propagation, sparse tables, heavy-light decomposition, centroid decomposition, treaps, Li Chao trees, Mo's algorithm, and persistent structures.
Phase 3Cross products, convex hull, point-in-polygon, line segment intersection, closest pair, sweep line, polygon area, rotating calipers, and half-plane intersection.
Phase 3Combinatorial game theory, Nim and Nim-sum, Sprague-Grundy theorem, Grundy numbers, minimax, alpha-beta pruning, Wythoff's game, and common CP game problems.
Phase 3Full competitive programming roadmap: Regular to Legendary tier algorithms, practice platforms, tournaments with prizes, and weekly training schedule.
Phase 3Go fundamentals, structs, interfaces, goroutines & channels, building HTTP backends, CLIs, testing, and concurrency patterns.
Phase 3Requirements gathering, estimation, components, trade-offs, and the system design interview framework.
Phase 3Containers from scratch -- images, Dockerfiles, volumes, networking, Compose, and production best practices.
Phase 3AWS/GCP/Azure, compute & storage, serverless, CI/CD, Terraform, load balancers, CDNs, and managed databases.
Phase 3Container orchestration -- Pods, Deployments, Services, scaling, self-healing, YAML configs, and kubectl.
Phase 3Message queues, Pub/Sub patterns, RabbitMQ, Apache Kafka, consumer groups, and event-driven architecture.
Phase 3Set up a VPS from scratch, SSH keys, firewalls, reverse proxies, SSL, Docker deployments, and self-hosted tools.
Phase 3How payments work, Payment Intents, Checkout, Elements, subscriptions, webhooks, testing, security, PCI compliance, and full Node.js integration examples.
Phase 3CAP theorem, consensus (Raft/Paxos), replication, sharding, consistent hashing, distributed transactions (2PC/sagas), gossip protocols, caching, rate limiting, idempotency, and observability.
Phase 3REST APIs, middleware, JWT/OAuth auth, rate limiting (token bucket, sliding window), pagination, caching (Redis), WebSockets, event-driven architecture, RabbitMQ, BullMQ, error handling, and deployment patterns.
Phase 31-2 Hard problems per day. Virtual contests on Codeforces/AtCoder weekly. Work through The 650 Problems. Target: Codeforces 1400+ rating. Start entering real competitions (ICPC, Google Code Jam, Meta Hacker Cup).
You know the theory. Now build real things. Master your ecosystem tooling, testing, and ship production software.
npm/yarn/pnpm, package.json, Webpack, Vite, esbuild, Babel, SWC, module resolution, linting, and monorepos.
Phase 4Vitest, Jest, mocking, spies, async testing, HTTP API testing, snapshots, coverage, TDD, and Playwright for E2E.
Phase 4Build CLIs, TUIs with Ink, HTTP APIs (Express/Fastify/Hono), SDKs, npm publishing, and Docker for TS.
Phase 4The best free resources to supplement your learning. Use these alongside this site.
Full-length university lectures on Pre-Algebra through Calculus III. The best maths teacher on YouTube -- explains everything from fundamentals with patience and clarity.
Highly RecommendedFree video lessons and practice for every maths topic from arithmetic to linear algebra. Perfect for filling gaps.
Beautiful visual explanations of linear algebra, calculus, and more. Watch Essence of Linear Algebra and Essence of Calculus.
Curated LeetCode roadmap with video explanations for every problem. The best free DSA resource.
Practice coding problems sorted by topic, difficulty, and company.
Animated visualizations of data structures and algorithms. See exactly how they work step by step.
Programming is a craft that glorifies God when you use it to serve others, build discipline, and steward the mind He gave you. Here are some ways to keep your faith at the center of your dev journey.
Start your coding day with Scripture. Short daily reading plans to keep God first. Try "Devotions for Developers" or any plan that fits your season.
DailyA global community of Christians in tech. Meetups, hackathons, and projects that use technology to serve the Kingdom.
Community"Whatever you do, work at it with all your heart, as working for the Lord." — Colossians 3:23. Let your grind honor God.
There's a growing narrative that you should just let AI write all your code and "focus on reviewing." That advice is for senior engineers who already paid the price of learning. As a student or early-career dev, you haven't built the mental models yet. Here's the truth:
Use AI as a teacher, not a replacement. When you hit something you don't understand, that's not a problem -- that's the curriculum.
Write the code yourself first. Struggle with it. Read the docs. Try and fail. Then if you're truly stuck, ask AI to explain the concept -- not to write the code for you.
If AI already wrote code you don't understand -- go back and learn it. It's not too late. Open every file, read every function, look up every library. Make the codebase yours. That's how you turn AI-assisted code into real knowledge.
The engineer on LinkedIn already paid the price of learning. He can review AI code because he spent years writing it himself first. You still need to pay that price. And honestly, paying it now while you're in university is the cheapest it'll ever be.
These aren't random portfolio projects. Each one forces you to use real algorithms and systems knowledge to solve real problems. You can't fake your way through these -- you either understand the algorithm or it doesn't work. Build them in order alongside the phases above.
Every project below has an algorithmic core and a systems core. You need both. A CRUD app teaches you nothing. A project where you have to implement edit distance, build a B-tree, or design a consistent hashing ring -- that's where growth happens. No AI when implementing the algorithm. Use AI for boilerplate and setup, never for the hard part.
The problem you already had. User listens to audio and types what they hear. You need to determine accuracy.
Algorithms: Levenshtein distance (edit distance), longest common subsequence, diff algorithm, fuzzy matching with string hashing.
Systems: WebSocket for real-time typing, REST API, PostgreSQL for storing results, Redis for session state.
What you'll learn: Why your char-map solution was O(1) but wrong, and why edit distance is O(nm) but correct. This is the project that bridges string algorithms to real software.
You already started this -- finish it and make it production-grade.
Algorithms: Hash tables with open addressing, B-trees for disk storage, LSM trees, bloom filters for fast negative lookups, LRU cache eviction.
Systems: TCP server, serialization/deserialization, file I/O, WAL (write-ahead log) for crash recovery, goroutine-per-connection concurrency.
Levels: Level 1: in-memory hashmap with TCP interface. Level 2: persist to disk with B-tree. Level 3: add TTL, LRU eviction. Level 4: add replication to a second node.
Simple concept, deep execution.
Algorithms: Base62 encoding, consistent hashing for distribution, HyperLogLog for unique visitor counting, bloom filters to check if URL exists without DB hit.
Systems: Rate limiting (sliding window), caching (Redis), database design (PostgreSQL), background job to aggregate analytics, API design.
What you'll learn: How to think about scale. What happens when you have 100M URLs? That's where the algorithms matter.
Build a search engine that indexes and searches text documents.
Algorithms: Inverted index, TF-IDF ranking, trie for autocomplete, string hashing for deduplication, edit distance for "did you mean?" suggestions.
Systems: File crawling, concurrent indexing, query parsing, HTTP API for search, pagination with cursor-based approach.
What you'll learn: How Google actually works at a basic level. Tries, inverted indexes, and ranking algorithms are used everywhere.
Route HTTP requests across multiple backend servers.
Algorithms: Round-robin, weighted round-robin, least connections (min-heap), consistent hashing (hash ring with virtual nodes), health check with exponential backoff.
Systems: TCP/HTTP proxying, goroutines for concurrent connections, graceful shutdown, connection draining, metrics endpoint.
What you'll learn: How NGINX and cloud load balancers work. Consistent hashing is asked in every system design interview.
Send raw UDP packets and resolve domain names.
Algorithms: Binary parsing (DNS packet format), trie for cache lookup, LRU eviction, recursion (root -> TLD -> authoritative).
Systems: UDP sockets, binary protocol implementation, caching with TTL, concurrent request handling.
What you'll learn: How the internet actually works at the DNS level. Parsing binary protocols is a skill most web devs never learn.
Publish a real rate limiting library to npm and Go modules.
Algorithms: Token bucket, sliding window log, sliding window counter, fixed window. Each is a different trade-off.
Systems: Redis integration for distributed rate limiting, middleware pattern for Express/Gin, thread safety, benchmarking.
What you'll learn: How to build and publish a real library. Rate limiting appears in every backend system.
The ultimate systems project. Build a simple SQL database.
Algorithms: B+ tree for indexes, query parsing (recursive descent parser), hash join, sort-merge join, buffer pool (LRU page replacement).
Systems: Page-based file storage, WAL for crash recovery, lock manager for transactions, SQL tokenizer and parser.
What you'll learn: How PostgreSQL works under the hood. This is the project that separates good engineers from great ones. Only attempt after completing Phase 3 of the site.
Another CRUD todo app -- teaches nothing new.
A portfolio website -- not engineering, it's design.
An AI wrapper -- calling an API is not engineering. The API call is 3 lines. The interesting part is the system around it (queue, caching, rate limiting).
A "vibe coded" SaaS -- if AI wrote 90% of it, you learned 10% of it. Ship it for money if you want, but don't count it as learning.
1. Typing Accuracy Service -- you already have the problem in your head. Implement Levenshtein distance yourself. Build the WebSocket server. This bridges what you already know to what you need to learn.
2. Finish the KV Store in Go -- get it to Level 3 (disk persistence + LRU eviction). This is your systems foundation project.
3. URL Shortener -- quick to build, teaches database design, caching, and rate limiting. Good for interviews.
4. Search Engine OR Load Balancer -- pick whichever excites you more. Both are Phase 3 projects that will push you hard.
5. Database from Scratch -- this is the final boss. Attempt this after you've done the others and completed Phase 3 of the site.
The site is organized so that scrolling down IS the roadmap. Phase 1 → Phase 2 → Phase 3 → Phase 4. Go through each card in order. By the time you finish Phase 4, you'll have the math, algorithms, systems knowledge, and practical skills to be a cracked backend and systems engineer.
1. Start at Phase 1, card 1. Open each topic in order. Read it. Do the practice problems. Move to the next card.
2. Don't skip ahead. Every topic builds on the previous ones. If you skip Discrete Math, you won't understand graph theory. If you skip Binary Systems, bit manipulation problems will destroy you.
3. Do LeetCode alongside. Each phase has a LeetCode target at the bottom. Hit it daily.
4. The numbered roadmap bars show the exact order. Follow the numbers 1 through 30. That's it. That's the plan.
Morning (30 min): Bible/prayer. Set your mind right before anything else.
Morning (30-45 min): 1 LeetCode problem, timed. No AI. If you solve it, move on. If you can't after 25 min, read the solution approach (not code), then implement it yourself.
Afternoon (2-3 hrs): Study from this site -- one topic per session. Read the theory, then do the practice problems by hand. Take notes.
Evening (1-2 hrs): Build your current project. Implement one feature per session. The algorithm part gets done without AI. The boilerplate (Express setup, Docker config) is fine with AI.
Saturday: Virtual contest (Codeforces Div 2 or LeetCode weekly). Even if you only solve 1-2 problems, that's progress. Review the editorial for every problem you couldn't solve.
Sunday: Rest. Church. No code. This is non-negotiable. Burnout is real and it's already hit you. Rest is what makes the other 6 days work.
If you can't focus, if you're watching anime all day, if you're binge eating and lying in bed -- that's burnout, not laziness. It means you've been sprinting too hard without recovery.
The fix is not "try harder." The fix is: pick ONE thing. Not LeetCode AND networking revision AND SharpSharp AND exams AND job apps. ONE thing per day. Today it might just be "solve one Easy problem." Tomorrow it might be "read one section of this site." Small consistent actions beat heroic sprints every time.
You got a Google internship from Kent. You've built real software for real clients. You're not behind. You're just tired. Rest, then start small.