AI Engineer roadmap

Everything worth learning to build and operate production LLM systems, ordered so each layer holds up the next. Tick things off as you learn them - progress is saved.

14 stages375 topics

All roadmaps
0 of 375 done
Essential, don't skip Recommended, skip only with a reason Optional, awareness is enough Course on PracticAI
1

Programming Foundations

                      2

                      Data Handling

                              3

                              Machine Learning Basics

                                              4

                                              Deep Learning Basics

                                                          5

                                                          NLP for Applications

                                                                              6

                                                                              Transformers

                                                                                                  7

                                                                                                  LLM Engineering

                                                                                                                          8

                                                                                                                          RAG

                                                                                                                                              9

                                                                                                                                              Agents and Tool Use

                                                                                                                                                              10

                                                                                                                                                              Backend Engineering

                                                                                                                                                                                  11

                                                                                                                                                                                  Data Stores

                                                                                                                                                                                                  12

                                                                                                                                                                                                  Evaluation and Observability

                                                                                                                                                                                                          13

                                                                                                                                                                                                          Deployment and Operations

                                                                                                                                                                                                                          14

                                                                                                                                                                                                                          Professional Practice

                                                                                                                                                                                                                                  Capstone

                                                                                                                                                                                                                                  One production-style AI knowledge assistant, containing:

                                                                                                                                                                                                                                  • Document ingestion pipeline
                                                                                                                                                                                                                                  • Hybrid retrieval with reranking
                                                                                                                                                                                                                                  • Grounded answers with citations
                                                                                                                                                                                                                                  • Tool calling with human approval
                                                                                                                                                                                                                                  • FastAPI backend with auth
                                                                                                                                                                                                                                  • PostgreSQL and vector storage
                                                                                                                                                                                                                                  • Redis caching
                                                                                                                                                                                                                                  • Background processing
                                                                                                                                                                                                                                  • Tests with mocked providers
                                                                                                                                                                                                                                  • Retrieval and LLM evaluation
                                                                                                                                                                                                                                  • Traces, latency and cost monitoring
                                                                                                                                                                                                                                  • Docker and cloud deployment

                                                                                                                                                                                                                                  Finish with one strong end-to-end capstone and two smaller projects, not a dozen abandoned tutorials.

                                                                                                                                                                                                                                  Anyone can wire up a model call. The engineers who get hired are the ones whose systems keep working when the model returns garbage, the vector store is slow, and someone pastes a prompt injection into a support ticket.