Split View: 2025 IT 취업 합격을 위한 기술스택별 공부 로드맵: 무료/유료 학습 리소스 총정리

The Definitive 2025 Developer Study Guide: Tech Stack Roadmaps, Free Resources, and Interview Prep for Every Position

• Introduction: The Study Plan Nobody Gave You
• 1. How to Actually Read a Job Description
  • The "Required" vs "Nice to Have" Distinction
  • The T-Shaped Developer Strategy
  • Realistic Timelines
• 2. Coding Interview Preparation
  • Problem Lists: The Big Three
  • Platforms
  • Essential GitHub Repositories
  • The 3-Month Coding Interview Timeline
• 3. System Design Interview Preparation
  • Books: The Core Three
  • Online Courses
  • Free Resources
  • System Design Topic Checklist
  • Practice Problems (Ordered by Difficulty)
• 4. Backend Engineer Roadmap
  • Languages and Frameworks
  • Databases
  • The 6-Month Backend Roadmap
• 5. Frontend Engineer Roadmap
  • Premium Courses (Worth Every Dollar)
  • Free Resources
  • The RSC Opportunity: Early Mover Advantage
  • The 6-Month Frontend Roadmap
• 6. AI/ML Engineer Roadmap
  • Free Foundations
  • RAG and LLM Application Development
  • Model Context Protocol (MCP)
  • The learn-ai-engineering Repository
  • The 8-Month AI/ML Roadmap
• 7. DevOps / Platform Engineer Roadmap
  • Certifications: The Priority Stack
  • Learning Platforms
  • Suggested Certification Order
• 8. Data Engineer Roadmap
  • Free and Low-Cost Foundations
  • Premium Resources
  • Tool-Specific Learning
  • The 8-10 Month Data Engineering Roadmap
• 9. Free Resources Masterlist
  • YouTube Channels
  • University Courses (Free)
  • GitHub Repositories (The Essential Five)
• 10. Portfolio and GitHub Strategy
  • GitHub Profile Best Practices
  • Open Source Contribution Guide
  • Portfolio Project Ideas by Category
• 11. Budget Tiers: Invest Strategically
  • Zero Budget ($0)
  • Mid Budget ($200-500/year)
  • Premium Budget ($500-1500/year)
• 12. Conclusion: Your First 4-Week Action Plan
  • Week 1: Audit and Decide
  • Week 2: Foundations
  • Week 3: Build Something
  • Week 4: Review and Adjust
• References

Introduction: The Study Plan Nobody Gave You

Every year, thousands of developers stare at job descriptions that read like laundry lists of technologies they have never touched. The gap between "where I am" and "what the market wants" feels enormous, and the sheer volume of tutorials, courses, certifications, and GitHub repositories available only makes it worse. Analysis paralysis is the default state.

This guide is the antidote.

What follows is a single, structured document covering every major developer career track in 2025 — backend, frontend, AI/ML, DevOps, and data engineering — with specific resources, realistic timelines, actual prices, and battle-tested study sequences. No vague advice to "just build projects." No hand-waving about "staying curious." Every recommendation here has been vetted against community consensus from Hacker News, Reddit engineering subs, Blind, and thousands of developer interviews.

Whether you are a bootcamp graduate trying to land your first role, a mid-career engineer pivoting into AI, or a senior developer preparing for staff-level system design interviews, there is a section for you. Bookmark this page. You are going to need it.

---

1. How to Actually Read a Job Description

Before spending a single hour studying, you need to learn the meta-skill that most developers skip: reading job descriptions strategically.

The "Required" vs "Nice to Have" Distinction

Every JD has two sections that matter, and most candidates misread both.

Required qualifications are negotiable roughly 70% of the time. Hiring managers write aspirational JDs. If the listing says "5+ years of Go experience" and you have 3 years of Go plus 2 years of Rust, you are a viable candidate. Research from LinkedIn's 2024 hiring data shows that the average successful hire meets about 60-70% of listed requirements.

Nice to have / preferred qualifications are where companies reveal what they actually dream about. If "Kubernetes" or "Terraform" appears here, it means the team is moving in that direction and will pay a premium for someone who can accelerate the transition.

The key heuristic: Apply if you meet 60% of "required" and any of "nice to have." Most of your competition is self-selecting out of roles they could absolutely fill.

The T-Shaped Developer Strategy

The most employable engineers in 2025 are T-shaped: deep expertise in one domain, broad literacy across adjacent ones.

The vertical bar is what gets you hired. The horizontal bar is what gets you promoted and makes you resilient to market shifts.

Realistic Timelines

Stop believing that you can master a new tech stack in "a weekend." Here is what real learning actually looks like:

• 3 months: Enough to be productive in a new language/framework. You can contribute to an existing codebase and pass a junior-to-mid coding interview in that stack.
• 6 months: Enough to design and build a production-quality project from scratch. You can pass a mid-level system design interview and mentor others in the basics.
• 12 months: Enough to call yourself proficient. You understand the edge cases, the footguns, the ecosystem tradeoffs. You can pass a senior-level interview and make architectural decisions.

These timelines assume 1-2 hours of focused study per day, 5 days a week — roughly the pace of someone with a full-time job who is serious about a transition.

---

2. Coding Interview Preparation

The coding interview remains the gatekeeper for the vast majority of software engineering roles. Love it or hate it, you need to get through it. Here is the most efficient path.

Problem Lists: The Big Three

Not all LeetCode grinding is created equal. The community has converged on three curated lists that provide maximum coverage with minimum redundancy.

Blind 75 (2-3 weeks)

The original curated list, created by a Facebook engineer on the Blind app. Seventy-five problems covering every major pattern: arrays, binary search, dynamic programming, graphs, trees, intervals, linked lists, matrices, strings, and heaps. This is the highest-signal list if you are short on time.

• Time commitment: 2-3 weeks at 3-5 problems per day
• Best for: Experienced developers refreshing before interviews
• Link: Search "Blind 75" on NeetCode for the organized version with video solutions

Grind 75 (Customizable)

Created by Yangshun Tay (author of Tech Interview Handbook), Grind 75 is the spiritual successor to Blind 75. Its killer feature is a configurable study plan — you enter how many hours per week you can study, which weeks you want to focus on, and it generates a personalized schedule.

• Time commitment: Configurable from 1 to 26 weeks
• Best for: Anyone who wants a structured, adjustable plan
• Link: https://www.techinterviewhandbook.org/grind75

NeetCode 150 (4-8 weeks)

The most comprehensive of the three. 150 problems organized by pattern, with video explanations for every single one. NeetCode (the creator) walks through the brute force solution first, then optimizes step by step — an invaluable approach for building intuition.

• Time commitment: 4-8 weeks at 3-5 problems per day
• Best for: Developers who want thorough preparation and learn well from video
• Link: https://neetcode.io/practice

Platforms

LeetCode — The industry standard. Free tier includes 2,800+ problems. Premium ($35/month or$159/year) unlocks company-tagged problems, which is genuinely useful — if you are interviewing at Google, you can filter for problems that Google actually asks. The frequency data alone can be worth the subscription.

NeetCode — Free YouTube channel with 400+ video solutions. NeetCode Pro ($119/year) adds a structured course, progress tracking, and additional problems. The video quality is exceptional — clear explanations with visual diagrams.

AlgoExpert ($199/year) — 200 curated problems with video walkthroughs by Clement Mihailescu. More polished than LeetCode, less community-driven. Best for developers who prefer a self-contained curriculum over an open platform.

CodeSignal — Increasingly used by companies (Uber, Brex, Robinhood) as a direct screening tool. If your target company uses CodeSignal, practice on their platform. General Assessment scores are reusable across companies.

Essential GitHub Repositories

Two repositories have become canonical references:

coding-interview-university (338k+ stars) — Created by John Washam, who used it to study for 8 months and land a job at Amazon. This is not a problem list; it is a complete computer science curriculum covering data structures, algorithms, networking, operating systems, and more. Think of it as a self-directed CS degree.

GitHub: https://github.com/jwasham/coding-interview-university

tech-interview-handbook (120k+ stars) — Yangshun Tay's comprehensive guide covering resume writing, behavioral questions, negotiation, and coding prep. The "Grind 75" list lives here. Practical, well-organized, and regularly updated.

GitHub: https://github.com/yangshun/tech-interview-handbook

The 3-Month Coding Interview Timeline

The golden rule: If you cannot solve a problem in 20 minutes, read the solution. Understanding the pattern is more valuable than struggling for hours. Come back to the problem in 3 days and solve it from scratch.

---

3. System Design Interview Preparation

System design interviews separate mid-level from senior candidates. There is no way to fake this — you either understand distributed systems tradeoffs or you do not. The good news: the material is finite and learnable.

Books: The Core Three

Designing Data-Intensive Applications (DDIA) by Martin Kleppmann (~$40)

The foundational text. Kleppmann covers replication, partitioning, transactions, batch processing, and stream processing with a depth that no course matches. This is not a "system design interview prep book" — it is a real engineering textbook that happens to make you excellent at system design interviews.

• Time commitment: 4-6 weeks for a careful first read
• Best approach: Read one chapter per week, take notes, discuss with someone

System Design Interview by Alex Xu, Volume 1 and Volume 2 (~$35 each)

The most practical interview prep books available. Each chapter walks through a specific system (rate limiter, URL shortener, news feed, chat system, YouTube-like video platform) with step-by-step designs. Volume 2 covers more advanced systems: proximity service, Google Maps-like navigation, distributed email service, S3-like object storage, and real-time gaming leaderboard.

• Time commitment: 2-3 weeks per volume
• Best approach: Sketch each design on paper before reading the solution

Software Architecture: The Hard Parts by Neal Ford, Mark Richards, Pramod Sadalage, Zhamak Dehghani (~$50)

Goes beyond interview prep into real architectural decision-making. Covers trade-off analysis, service granularity, data ownership, distributed transactions (saga pattern, two-phase commit), and contract management. Best for senior/staff-level candidates.

Online Courses

ByteByteGo by Alex Xu ($189/year) — The companion platform to his books. Weekly articles, visual explainers, and a newsletter that reaches 500k+ subscribers. The visual system design diagrams are the best in the industry. Worth it if you are a visual learner.

Grokking the System Design Interview on Educative ($79/year for Educative Unlimited) — The original system design course that started the genre. Text-based (no video), which means you can go at your own pace. Covers 15+ system designs with detailed diagrams and scalability analysis. Educative Unlimited also gives you access to Grokking the Coding Interview and dozens of other courses.

Codemia.io (Free+) — A newer platform focused specifically on system design practice. Free tier includes a subset of problems. The interactive design canvas lets you draw architectures and get feedback.

Free Resources

AlgoMaster.io System Design PDF — A comprehensive, free PDF covering all major system design topics with diagrams. Popular on Reddit and Hacker News. Direct download from the AlgoMaster.io website.

Gaurav Sen YouTube Channel — Over 100 system design videos, each 15-25 minutes. Covers consistent hashing, load balancing, database sharding, message queues, and specific system designs. Free and well-produced.

system-design-primer (280k+ stars on GitHub) — Donne Martin's massive repository covering scalability, latency, throughput, availability, consistency patterns, DNS, CDNs, load balancers, reverse proxies, databases, caches, asynchronism, and communication patterns. The single most comprehensive free system design resource.

GitHub: https://github.com/donnemartin/system-design-primer

System Design Topic Checklist

Use this checklist to track your preparation across all major domains:

Fundamentals

• Horizontal vs vertical scaling
• CAP theorem and its practical implications
• Consistent hashing
• Rate limiting (token bucket, sliding window)
• Load balancing strategies (round-robin, least connections, consistent hashing)

Storage

• SQL vs NoSQL decision framework
• Database replication (leader-follower, multi-leader, leaderless)
• Database partitioning (range, hash, composite)
• Indexing strategies (B-tree, LSM-tree, inverted index)
• Caching patterns (cache-aside, write-through, write-behind)

Communication

• REST vs gRPC vs GraphQL
• Synchronous vs asynchronous communication
• Message queues (Kafka, RabbitMQ, SQS)
• WebSocket vs Server-Sent Events vs long polling

Infrastructure

• CDN design and cache invalidation
• DNS and domain name resolution
• API gateway patterns
• Service discovery (client-side vs server-side)
• Circuit breaker and retry patterns

Practice Problems (Ordered by Difficulty)

1. URL shortener (Beginner)
2. Rate limiter (Beginner)
3. Key-value store (Beginner-Intermediate)
4. Unique ID generator (Intermediate)
5. Web crawler (Intermediate)
6. Notification system (Intermediate)
7. News feed system (Intermediate-Advanced)
8. Chat system (Advanced)
9. Search autocomplete (Advanced)
10. YouTube / Netflix video streaming (Advanced)
11. Google Maps navigation (Expert)
12. Distributed message queue (Expert)

---

4. Backend Engineer Roadmap

Backend engineering is the broadest track, and the one where language choice matters most for your first few years. Here is a pragmatic breakdown.

Languages and Frameworks

Python / FastAPI

Python remains the fastest path to a productive backend. FastAPI has emerged as the modern standard, offering automatic OpenAPI documentation, type validation via Pydantic, async support, and performance that rivals Node.js for I/O-bound workloads.

• Official Tutorial: https://fastapi.tiangolo.com/tutorial/
• Time to productivity: 2-4 weeks (assuming Python knowledge)
• Best for: Startups, ML-adjacent backends, rapid prototyping
• When to avoid: CPU-bound workloads, ultra-low-latency requirements

Java / Spring Boot

The enterprise workhorse. Spring Boot is the most-used backend framework in Fortune 500 companies. The learning curve is steeper, but the ecosystem (Spring Security, Spring Data, Spring Cloud) is unmatched for complex enterprise applications.

• Official Guides: https://spring.io/guides
• Baeldung (free tutorials): https://www.baeldung.com/
• Time to productivity: 4-8 weeks
• Best for: Enterprise software, fintech, large teams, microservices at scale

Go (Golang)

Go is the language of cloud infrastructure. Docker, Kubernetes, Terraform, Prometheus — all written in Go. If you want to work on infrastructure, platform engineering, or high-performance networking, Go is the most strategic choice.

Learning path:

1. A Tour of Go (free): https://go.dev/tour/ — Interactive browser-based tutorial. Complete in 1-2 days.
2. Go by Example (free): https://gobyexample.com/ — Annotated code examples covering every language feature. Excellent as a reference.
3. Learn Go with Tests (free): https://quii.gitbook.io/learn-go-with-tests — TDD-driven approach to learning Go. Teaches testing culture alongside language features.
4. Boot.dev ($29/month): Gamified backend learning platform with a strong Go track. Covers Go, HTTP servers, databases, and algorithms in a structured curriculum.

• Time to productivity: 3-5 weeks
• Best for: Infrastructure tools, high-concurrency servers, microservices, CLI tools

Rust

Rust is not the fastest path to employment, but it is the highest-signal skill on a resume. Companies that use Rust (Cloudflare, Discord, Figma, AWS) are acutely aware of how few Rust developers exist, and they pay accordingly.

Learning path:

1. The Rust Book (free): https://doc.rust-lang.org/book/ — The official guide. Chapters 1-12 are essential; 13-20 are advanced topics you can revisit.
2. Rustlings (free): https://github.com/rust-lang/rustlings — Small exercises that get you reading and writing Rust code. Pairs perfectly with The Rust Book.
3. Rust by Example (free): https://doc.rust-lang.org/rust-by-example/ — Code-first approach to learning Rust.

• Time to productivity: 6-10 weeks (the borrow checker adds time)
• Best for: Performance-critical systems, WebAssembly, embedded, security-critical code

Databases

PostgreSQL

The default choice for relational data. If you learn one database deeply, make it Postgres.

• PostgreSQL Tutorial: https://www.postgresqltutorial.com/ — Covers basics through advanced topics (CTEs, window functions, full-text search)
• Use The Index, Luke (free): https://use-the-index-luke.com/ — The definitive guide to database indexing. Written for all SQL databases but particularly relevant for Postgres. Understanding indexing is probably the single highest-ROI database skill.

Redis

In-memory data structure store used for caching, session management, rate limiting, pub/sub, and real-time leaderboards.

• Redis University (free!): https://university.redis.io/ — Official free courses covering Redis basics, data modeling, and advanced patterns. Certificates included. One of the best free learning resources in all of tech.

MongoDB

The most popular document database. Useful for prototyping and applications with genuinely flexible schemas.

• MongoDB University (free): https://learn.mongodb.com/ — Official free courses. The M001 (Basics) and M320 (Data Modeling) courses are the most valuable.

The 6-Month Backend Roadmap

---

5. Frontend Engineer Roadmap

Frontend engineering in 2025 is simultaneously simpler and more complex than it was five years ago. The frameworks have matured, but the paradigm shift toward server components has redrawn the map.

Premium Courses (Worth Every Dollar)

Epic React by Kent C. Dodds ($695)

Recently updated for React 19 and TypeScript. Covers hooks, patterns, performance optimization, testing, and advanced component design. The exercises are exceptional — you build real features, not toy examples. If you can afford one premium course, this is the one.

• Best for: Intermediate developers who want to reach senior level in React
• Format: Video + interactive exercises
• Estimated time: 40-60 hours

The Joy of React by Josh W. Comeau ($599)

The most beautifully designed programming course on the internet. Josh is a former Gatsby engineer whose visual explanations of CSS, layout, and React internals are unmatched. Covers React fundamentals through advanced patterns with interactive widgets that let you manipulate code and see results in real time.

• Best for: Visual learners, developers who want deep understanding (not just syntax)
• Format: Interactive web-based lessons
• Estimated time: 60-80 hours

CSS for JavaScript Developers by Josh W. Comeau ($399)

If you have ever struggled with CSS (who has not?), this course will fundamentally change your relationship with it. Covers the box model, layout algorithms (flexbox, grid), positioning, responsive design, animations, and CSS variables — all through an interactive, mental-model-first approach.

• Best for: Any developer who uses CSS and wants to stop guessing
• Format: Interactive web-based lessons
• Estimated time: 40-50 hours

Free Resources

Next.js Learn (free): https://nextjs.org/learn — The official Next.js tutorial. Builds a full application step by step, covering file-based routing, data fetching, server actions, streaming, authentication, and deployment. Updated for the App Router.

TypeScript Handbook (free): https://www.typescriptlang.org/docs/handbook/ — The official TypeScript documentation. Start with "The Basics" and "Everyday Types," then jump to "Generics" and "Utility Types" when you need them.

React Documentation (free): https://react.dev/ — The new React docs (react.dev, not the legacy site) are outstanding. The "Learn React" section is a complete course, and the "Escape Hatches" section on effects and refs is essential reading for intermediate developers.

roadmap.sh Frontend Roadmap (free): https://roadmap.sh/frontend — A visual, community-driven roadmap showing every technology in the frontend ecosystem and suggested learning order. Updated regularly.

The RSC Opportunity: Early Mover Advantage

React Server Components (RSC) have a real-world adoption rate of approximately 29% as of early 2025 (based on State of JS and State of React surveys). This means understanding RSC deeply puts you ahead of 70% of React developers.

The key concepts to master:

• Server Components vs Client Components: Server Components run only on the server, have zero JavaScript bundle cost, and can directly access databases and file systems. Client Components run in the browser and handle interactivity.
• The "use client" directive: The boundary that marks where server rendering stops and client hydration begins.
• Server Actions: Functions that run on the server but can be called from the client, replacing traditional API routes for form mutations.
• Streaming and Suspense: Progressively rendering UI as data becomes available, rather than waiting for everything to load.

If you learn these concepts now and can articulate them in an interview, you have a genuine competitive advantage.

The 6-Month Frontend Roadmap

---

6. AI/ML Engineer Roadmap

The AI/ML engineering landscape has fundamentally shifted. In 2023, the job was "train models." In 2025, the job is "build systems that use models." The skills that matter have changed accordingly.

Free Foundations

Andrej Karpathy's "Zero to Hero" (free YouTube series)

The single best introduction to neural networks in existence. Karpathy (former OpenAI, former Tesla AI Director) builds neural networks from scratch in Python — starting with a simple bigram model and ending with a GPT-class transformer. No frameworks, no black boxes.

• Playlist: Search "Neural Networks: Zero to Hero" on YouTube
• Time commitment: 15-20 hours
• Prerequisites: Basic Python, high school math

fast.ai Practical Deep Learning for Coders (free)

Jeremy Howard's top-down approach: start by training models that work, then progressively understand why they work. Covers image classification, NLP, tabular data, and recommendation systems. Uses PyTorch.

• Link: https://course.fast.ai/
• Time commitment: 40-60 hours
• Best for: Developers who learn best by doing

DeepLearning.AI Specializations (free to audit on Coursera)

Andrew Ng's courses remain the gold standard for structured ML education. The Deep Learning Specialization (5 courses) covers neural networks, CNNs, RNNs, and transformers. The Machine Learning Specialization (3 courses) is the updated version of his legendary Stanford course.

• Link: https://www.deeplearning.ai/
• Time commitment: 60-80 hours per specialization
• Best for: Developers who prefer academic rigor

Hugging Face NLP Course (free)

The best free NLP-specific course. Covers transformers, tokenization, fine-tuning, and the Hugging Face ecosystem (Transformers, Datasets, Tokenizers, Accelerate). Since the Hugging Face Hub is effectively the package manager for ML models, understanding this ecosystem is essential.

• Link: https://huggingface.co/learn/nlp-course
• Time commitment: 20-30 hours

LLM101n by Andrej Karpathy (free, in progress)

Karpathy's latest project: building an LLM from scratch, step by step. Covers tokenization, embeddings, attention, and training at a level of detail no other resource matches.

• GitHub: https://github.com/karpathy/LLM101n

RAG and LLM Application Development

This is where 2025 AI engineering jobs actually live. You need to know how to build applications that use LLMs effectively.

DeepLearning.AI RAG Courses (free short courses)

Several short courses (1-2 hours each) covering retrieval-augmented generation, vector databases, embeddings, and evaluation. Taught by practitioners from LangChain, LlamaIndex, Weaviate, Pinecone, and Chroma.

• Link: https://www.deeplearning.ai/short-courses/

LangChain Documentation and Tutorials

LangChain is the most widely used framework for building LLM applications. The documentation includes tutorials for building chatbots, RAG systems, agents, and tool-use pipelines.

• Link: https://python.langchain.com/docs/

LlamaIndex

An alternative to LangChain, focused specifically on connecting LLMs to data. Stronger for RAG use cases. The documentation includes end-to-end tutorials.

• Link: https://docs.llamaindex.ai/

Vector Databases

Understanding vector databases is now a core AI engineering skill. The major options:

• Pinecone: Fully managed, easiest to start with. Free tier available.
• Weaviate: Open source, supports hybrid search (vector + keyword).
• Chroma: Lightweight, open source, designed for prototyping.
• Qdrant: Open source, Rust-based, high performance.
• pgvector: PostgreSQL extension. Best if you already run Postgres and want to avoid adding infrastructure.

Model Context Protocol (MCP)

MCP is an open standard (introduced by Anthropic) for connecting AI models to external tools and data sources. It is rapidly becoming the standard protocol for AI agent interoperability.

Official MCP Documentation (free): https://modelcontextprotocol.io/ — The specification, quickstart guide, and reference implementations. Start here.

Anthropic MCP Courses (free): Available on the Anthropic developer portal. Cover MCP architecture, building MCP servers, and integrating MCP with Claude and other models.

MCP SDKs: Official SDKs available in Python and TypeScript. The TypeScript SDK is particularly well-documented.

MCP.so: A community directory of MCP servers and tools. Useful for discovering what is already available and getting inspiration for your own MCP integrations.

The learn-ai-engineering Repository

GitHub: https://github.com/patchy631/ai-engineering — A curated collection of resources, tutorials, and project ideas specifically for AI engineers (as opposed to ML researchers). Covers prompt engineering, RAG, fine-tuning, evaluation, and deployment.

The 8-Month AI/ML Roadmap

---

7. DevOps / Platform Engineer Roadmap

DevOps and platform engineering roles are certification-heavy. Unlike other tracks, certifications here genuinely move the needle on both hiring and compensation. Here is the strategic order.

Certifications: The Priority Stack

Certified Kubernetes Administrator (CKA)

Kubernetes is the backbone of modern infrastructure. The CKA is the most respected DevOps certification and the one most frequently listed in job descriptions.

• Prep platform: KodeKloud ($30/month) — Mumshad Mannambeth's courses with hands-on labs. The built-in terminal environments let you practice kubectl commands without setting up your own cluster.
• Exam cost: $445 (includes one free retake)
• Study time: 8-12 weeks
• Format: Performance-based (you solve real tasks in a live cluster, not multiple choice)
• Pass rate: ~65% on first attempt
• Scope: Revised February 2025 — the exam now covers updated Kubernetes APIs and deprecations. Make sure your study materials are post-February 2025.

Terraform Associate

Infrastructure as Code is a non-negotiable skill. The Terraform Associate certification proves you understand HCL syntax, state management, modules, workspaces, and the Terraform workflow.

• Prep: HashiCorp Learn (free): https://developer.hashicorp.com/terraform/tutorials — Official tutorials covering everything on the exam.
• Exam cost: $70.50
• Study time: 4-6 weeks
• Format: Multiple choice + multiple select
• Pass rate: ~70%

AWS Solutions Architect Associate (SAA-C03)

The most popular cloud certification in the world. Covers a broad range of AWS services: compute (EC2, Lambda, ECS), storage (S3, EBS, EFS), databases (RDS, DynamoDB, ElastiCache), networking (VPC, Route 53, CloudFront), and security (IAM, KMS, WAF).

• Prep: Adrian Cantrill's course ($40) — Widely considered the best AWS training available. Cantrill explains concepts from first principles with detailed diagrams, not just exam-focused memorization.
• Exam cost: $150
• Study time: 6-8 weeks
• Format: Multiple choice + multiple response (65 questions, 130 minutes)

AWS Solutions Architect Professional (SAP-C02)

The senior-level AWS certification. Covers everything in the Associate plus advanced topics: multi-account strategies, migration planning, cost optimization at scale, disaster recovery, and complex hybrid architectures.

• Prep: Adrian Cantrill's course ($80) — Even more essential at this level because the exam tests deep understanding, not surface-level recall.
• Exam cost: $300
• Study time: 10-14 weeks
• Format: Multiple choice + multiple response (75 questions, 180 minutes)

Learning Platforms

KodeKloud ($228/year or$30/month)

The best value in DevOps education. Courses on Kubernetes, Docker, Ansible, Terraform, Prometheus, Linux, and more — all with hands-on lab environments. The labs are the key differentiator: you get real terminal access to practice without setting up local infrastructure.

Adrian Cantrill ($40-80 per course)

The gold standard for AWS training. Cantrill is a former AWS Solutions Architect who teaches with a depth and clarity that no competitor matches. His courses are long (40-80 hours each) because he does not skip anything. If you are pursuing AWS certifications, start here.

A Cloud Guru ($45/month or$359/year)

Broader course catalog covering AWS, Azure, GCP, Linux, and DevOps tools. Quality varies by instructor, but the hands-on labs (cloud sandboxes) and practice exams are solid. Now owned by Pluralsight.

Suggested Certification Order

For maximum career impact, pursue certifications in this sequence:

1. Terraform Associate (4-6 weeks, $70.50) — Quickest win, immediately useful
2. CKA (8-12 weeks, $445) — The biggest career multiplier
3. AWS SAA (6-8 weeks, $150) — Broadest applicability
4. AWS SAP (10-14 weeks, $300) — Senior-level differentiation

Total investment: ~$965 in exam fees +$200-400 in courses. Total time: ~7-10 months studying part-time. This stack on a resume will open doors at virtually any infrastructure-focused company.

---

8. Data Engineer Roadmap

Data engineering has become one of the highest-demand specializations in tech. The role sits at the intersection of backend engineering, database administration, and analytics — building the pipelines that move, transform, and serve data at scale.

Free and Low-Cost Foundations

Data Engineering Zoomcamp by DataTalks.Club (free)

The best free data engineering curriculum available. A 9-week cohort-based course covering:

• Week 1: Containerization (Docker) and infrastructure as code (Terraform)
• Week 2: Workflow orchestration (Mage/Prefect)
• Week 3: Data warehouse (BigQuery)
• Week 4: Analytics engineering (dbt)
• Week 5: Batch processing (Spark)
• Week 6: Stream processing (Kafka)
• Weeks 7-9: Project

The cohort format means you study alongside thousands of others, with Slack channels and peer support. Past cohort recordings are also available for self-paced study.

• Link: https://github.com/DataTalksClub/data-engineering-zoomcamp
• Time commitment: 9 weeks, 10-15 hours per week

DataCamp ($25/month or$300/year)

A structured, interactive platform with courses on SQL, Python, Spark, Airflow, and data modeling. The "Data Engineer" career track is well-organized. Not as deep as other resources, but excellent for building breadth quickly.

Premium Resources

DataExpert.io by Zach Wilson

Zach Wilson (no relation to the NFL quarterback) has built one of the most respected data engineering communities. His courses cover dimensional data modeling, data pipeline design, and the modern data stack. His free YouTube content and newsletter are excellent starting points.

StartDataEngineering (Blog + Course)

A blog and course platform focused on practical data engineering skills. Covers pipeline design patterns, testing strategies, and real-world architecture decisions.

Tool-Specific Learning

Apache Kafka

• Confluent Developer (free): https://developer.confluent.io/ — Official tutorials, courses, and hands-on exercises. The "Apache Kafka 101" course is the best starting point.
• Covers: Producers, consumers, topics, partitions, consumer groups, Kafka Streams, Kafka Connect, Schema Registry.

Apache Spark

• Databricks Academy (free): https://www.databricks.com/learn — Free courses on Spark, Delta Lake, and the Lakehouse architecture. The "Apache Spark Developer" learning path is comprehensive.
• Covers: RDDs, DataFrames, Spark SQL, structured streaming, performance tuning.

dbt (data build tool)

• dbt Learn (free): https://courses.getdbt.com/ — Official free courses covering dbt fundamentals, advanced materializations, testing, and documentation.
• dbt has become the standard for analytics engineering and transformation layers. Understanding dbt is increasingly required for data engineering roles.

Apache Airflow

• Official Docs and Tutorials: https://airflow.apache.org/docs/ — Comprehensive documentation covering DAG authoring, operators, sensors, XComs, and deployment.
• Astronomer Academy (free): Astronomer (the managed Airflow provider) offers free courses on Airflow fundamentals and best practices.

The 8-10 Month Data Engineering Roadmap

---

9. Free Resources Masterlist

The internet has made world-class technical education free. The challenge is not access — it is curation. Here are the resources that consistently rank highest across developer communities.

YouTube Channels

Fireship — Jeff Delaney's channel is the fastest way to understand any technology. His "X in 100 Seconds" series provides instant context on tools and frameworks. The longer tutorials (10-20 minutes) are dense with practical information.

ThePrimeagen — A former Netflix senior engineer who now streams full-time. Covers systems programming, Vim, Go, Rust, and opinionated takes on industry trends. Best for intermediate-to-senior developers who want to sharpen their thinking.

freeCodeCamp — The YouTube channel publishes full-length courses (4-12 hours each) on virtually every technology. Quality varies by instructor, but the best courses (Beau Carnes on data structures, Andrew Brown on cloud certifications) are outstanding.

Traversy Media — Brad Traversy has been creating web development tutorials for a decade. Practical, project-based, and beginner-friendly. Particularly strong on full-stack JavaScript.

NetworkChuck — Makes networking, Linux, and cybersecurity accessible and entertaining. The "you need to learn X RIGHT NOW" series is motivating even if the titles are clickbait.

The Net Ninja — Shaun Pelling creates focused, well-structured playlist series on specific technologies. Particularly strong on Node.js, React, Vue, and Firebase. Clean, no-nonsense teaching style.

Abdul Bari — The best algorithms teacher on YouTube. His explanations of sorting algorithms, graph algorithms, and dynamic programming are clearer than most paid courses. The Algorithms playlist is a genuine gem.

University Courses (Free)

MIT 6.006: Introduction to Algorithms

The gold standard computer science algorithms course. Taught by Erik Demaine and others at MIT. Covers sorting, searching, graph algorithms, dynamic programming, and amortized analysis. Available on MIT OpenCourseWare with full lecture videos, problem sets, and exams.

• Link: https://ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2020/
• Time commitment: 40-60 hours

Harvard CS50: Introduction to Computer Science

David Malan's legendary introductory CS course. Covers C, Python, SQL, HTML/CSS/JavaScript, and computer science fundamentals. The production quality is Hollywood-level, and Malan's teaching is genuinely world-class. Available free on edX.

• Link: https://cs50.harvard.edu/x/
• Time commitment: 60-80 hours

Stanford Algorithms Specialization (Coursera, free to audit)

Tim Roughgarden's two-part algorithms course. More theoretical than MIT 6.006 but builds deeper intuition. Covers divide-and-conquer, graph search, shortest paths, data structures, greedy algorithms, and dynamic programming.

• Link: Available on Coursera (search "Stanford Algorithms")
• Time commitment: 40-60 hours

GitHub Repositories (The Essential Five)

Each of these repositories is actively maintained and has been vetted by hundreds of thousands of developers. If you are not already starring them, start now.

---

10. Portfolio and GitHub Strategy

Your GitHub profile is your technical resume. Recruiters and hiring managers spend an average of 30 seconds scanning it. Here is how to make those 30 seconds count.

GitHub Profile Best Practices

1. Pin your 6 best repositories. Choose projects that demonstrate breadth and depth. Do not pin tutorial follow-alongs — pin original work.

2. Write proper READMEs. Every pinned repository needs:

• A one-line description of what the project does
• A screenshot or demo GIF
• Clear setup instructions
• The tech stack, listed explicitly
• What you learned or what makes this interesting

3. Use a profile README. Create a repository with the same name as your GitHub username and add a README.md. This renders on your profile page. Keep it brief: who you are, what you are working on, your tech stack, and how to reach you.

4. Maintain a contribution graph. Consistent green squares matter more than occasional bursts. Even small contributions — documentation fixes, dependency updates, test additions — count. Aim for activity 4-5 days per week.

5. Write meaningful commit messages. "fix bug" and "update" tell reviewers nothing. Use conventional commits or at least describe what changed and why.

Open Source Contribution Guide

Contributing to open source is the single most effective way to demonstrate real-world engineering skills. Here is the path from zero to consistent contributor:

Step 1: Find the right project.

• Look for projects with "good first issue" or "help wanted" labels
• Choose projects you actually use — you will understand the codebase faster
• GitHub Explore (https://github.com/explore) surfaces trending repositories
• first-contributions repository (https://github.com/firstcontributions/first-contributions) walks you through your first PR

Step 2: Start with documentation and tests.

• Documentation improvements are always welcome and teach you the codebase
• Adding tests for untested code is high-value and relatively low-risk
• These contributions build trust with maintainers before you tackle features

Step 3: Engage with the community.

• Read the CONTRIBUTING.md file before doing anything
• Comment on issues to discuss approaches before writing code
• Be responsive to code review feedback
• Follow the project's coding style exactly, even if you disagree with it

Step 4: Graduate to features and bug fixes.

• Once maintainers recognize your name, propose and implement features
• Reference the issue number in your PR description
• Include tests with every code change

Portfolio Project Ideas by Category

Backend

• URL shortener with analytics dashboard (Redis + PostgreSQL)
• Real-time chat application with WebSocket and message persistence
• API rate limiter library (token bucket algorithm)
• Job queue system with retry logic and dead letter queue

Frontend

• Interactive data visualization dashboard (D3.js or Recharts)
• Markdown editor with live preview and export
• Accessible component library with Storybook documentation
• Progressive web app with offline support

AI/ML

• RAG-powered document Q&A system
• Semantic search engine over a custom dataset
• AI agent that performs multi-step tasks using tool calling
• Fine-tuned model for a specific domain (code review, medical Q&A, etc.)

DevOps

• Kubernetes operator for a custom resource
• CI/CD pipeline template with security scanning
• Infrastructure-as-code project for a complete production environment
• Monitoring stack (Prometheus + Grafana + alerting rules)

Data Engineering

• Real-time data pipeline (Kafka to data warehouse)
• ETL framework with data quality checks and alerting
• Data lakehouse with Delta Lake or Apache Iceberg
• Analytics dashboard with dbt transformations and BI tool

---

11. Budget Tiers: Invest Strategically

Not everyone has the same budget for learning. Here are three tiers that deliver maximum value at every price point.

Zero Budget ($0)

You can build a competitive skill set without spending a single dollar. It will take longer, but the quality of free resources in 2025 is extraordinary.

Timeline impact: Add 2-3 months compared to paid resources, primarily because free resources require more self-direction.

Mid Budget ($200-500/year)

Strategic spending on a few key resources dramatically accelerates learning.

**Recommended allocation for $500**: LeetCode Premium ($159) + Educative ($79) + Cantrill AWS ($40) + KodeKloud 3 months ($90) + DDIA book ($40) + Alex Xu Vol 1 ($35) =$443

Premium Budget ($500-1500/year)

If learning is your primary investment, these resources provide the highest quality available.

**Recommended allocation for $1500**: Pick one premium frontend course ($399-695) + ByteByteGo ($189) + DDIA/Alex Xu ($110) + CKA exam + KodeKloud ($445 +$90) + LeetCode Premium ($159) =$1,392-$1,688

The key principle across all tiers: prioritize resources that provide structure and feedback, not just content. A course with exercises and labs is worth 10x a passive video playlist.

---

12. Conclusion: Your First 4-Week Action Plan

You have read 10,000+ words of resources and roadmaps. The risk now is information overload — saving this page and never acting on it. Here is a concrete 4-week action plan to turn this guide into motion.

Week 1: Audit and Decide

• Day 1-2: Read 5 job descriptions for roles you want. Highlight every technology mentioned. Tally the frequency.
• Day 3: Map your current skills against those JDs. Identify the 3 biggest gaps.
• Day 4-5: Choose ONE primary track from this guide (backend, frontend, AI/ML, DevOps, data engineering).
• Weekend: Set up your study environment. Create a GitHub repo for tracking progress. Block 1.5-2 hours daily in your calendar.

Week 2: Foundations

• Start the first resource in your chosen track's roadmap (Month 1 row).
• Begin the Blind 75 or Grind 75 list — 2 problems per day, even if they are Easy.
• Set up a simple note-taking system (Obsidian, Notion, or a plain markdown file in your repo).

Week 3: Build Something

• Apply what you learned in Week 2 to a small project. Do not plan a massive app — build a single feature end-to-end.
• Continue the coding problem list — increase to 3 problems per day.
• Read one chapter of DDIA or one Alex Xu system design.

Week 4: Review and Adjust

• Review what you built in Week 3. Write a README. Push it to GitHub.
• Assess your study schedule: are you maintaining 1.5-2 hours daily? Adjust if needed.
• Plan the next 4 weeks using the monthly roadmap for your track.
• Find one study partner or online community (Discord, Reddit, local meetup) for accountability.

The most important principle is not which resource you choose — it is consistency. Two hours of focused study every day for 6 months will take you further than 10-hour weekend binges that burn out after 3 weeks.

Start today. Not next Monday. Today.

---

Quiz: Test Your Understanding

Q1. When a job description lists "5+ years of Go experience" as required, what does the data suggest about how strictly this is enforced?

The average successful hire meets roughly 60-70% of listed requirements. If you have 3 years of Go and strong adjacent experience, you are likely a viable candidate. Most developers self-select out of roles they could realistically fill.

Q2. In the suggested system design preparation strategy, what makes DDIA (Designing Data-Intensive Applications) different from the Alex Xu books?

DDIA is a foundational engineering textbook that teaches deep understanding of distributed systems concepts (replication, partitioning, transactions, stream processing). The Alex Xu books are practical interview-prep guides that walk through specific system designs step by step. DDIA builds the mental models; Alex Xu shows how to apply them in interview format.

Q3. Why does the guide suggest that React Server Components (RSC) represent an "early mover advantage" for frontend engineers?

RSC adoption is approximately 29% as of early 2025. This means that deep understanding of Server Components, the "use client" directive, Server Actions, and streaming/Suspense puts you ahead of roughly 70% of React developers. It is a concrete, demonstrable skill gap that interviewers are actively looking for.

---

References

1. Kleppmann, Martin. Designing Data-Intensive Applications. O'Reilly Media, 2017. https://dataintensive.net/
2. Xu, Alex. System Design Interview Volumes 1 and 2. ByteByteGo, 2020-2022. https://bytebytego.com/
3. Washam, John. "coding-interview-university." GitHub. https://github.com/jwasham/coding-interview-university
4. Martin, Donne. "system-design-primer." GitHub. https://github.com/donnemartin/system-design-primer
5. Tay, Yangshun. "tech-interview-handbook." GitHub. https://github.com/yangshun/tech-interview-handbook
6. Linux Foundation. "Certified Kubernetes Administrator (CKA) Exam." https://training.linuxfoundation.org/certification/certified-kubernetes-administrator-cka/
7. HashiCorp. "Terraform Associate Certification." https://developer.hashicorp.com/certifications/infrastructure-automation
8. Karpathy, Andrej. "Neural Networks: Zero to Hero." YouTube. https://www.youtube.com/playlist?list=PLAqhIrjkxbuWI23v9cThsA9GvCAUhRvKZ
9. Anthropic. "Model Context Protocol." https://modelcontextprotocol.io/
10. DataTalks.Club. "Data Engineering Zoomcamp." GitHub. https://github.com/DataTalksClub/data-engineering-zoomcamp