How to Learn Generative AI: A Practical Roadmap
Start from the skills you already have. A developer who can build APIs needs a different first step from someone already training models. This roadmap shows what to learn, what to practise and how to check that you are ready to move on.
Choose your starting point and follow a GenAI learning sequence with exercises, readiness checks and projects for developers and ML practitioners. Build and evaluate generative applications, choosing retrieval and adaptation when they fit the task.
Quick answer
What is the right Generative AI roadmap?
Learn how generative models represent inputs and produce outputs, then build a small application with explicit evaluation. Study prompting, retrieval and model adaptation as different options. Choose text, image, audio or multimodal work according to your goal. This roadmap emphasizes LLM applications and provides optional branches for other modalities.
Sources and methodology · This roadmap is reviewed when production practices, tools or platform patterns materially change.
Stages
8
Last reviewed
16 September 2026
Stage 1: Programming, data and model foundations
Python, data handling and the basic vocabulary of generative models.
Generative applications are software; you cannot evaluate them without engineering fundamentals.
- What you learn
- Python and data handling.
- Tokenizers.
- Generative model vocabulary.
- Model APIs.
- What you should build
- Build a script that loads a pretrained tokenizer and encodes text.
- Ready when
- You can load a tokenizer and explain what tokenization does to input text.
- Common mistake
- Skipping programming fundamentals to jump straight into prompt engineering.
- Acceptance checks
- Load a tokenizer and explain what tokenization does to input text.
- Related resources
- Hugging Face LLM Course — Tokenizers and pretrained models
Stage 2: Tokens, embeddings and generative models
Understand how tokens become embeddings and how generative models produce outputs.
Knowing how models represent inputs helps you debug failures and choose retrieval strategies.
- What you learn
- Tokens and context windows.
- Embeddings.
- Generative model families.
- Sampling and decoding.
- What you should build
- Inspect embeddings for similar and dissimilar sentences and report the distances.
- Ready when
- You can inspect embeddings and explain why similar sentences have closer vectors.
- Common mistake
- Treating embeddings as magic numbers without understanding similarity.
- Acceptance checks
- Inspect embeddings and explain why similar sentences have closer vectors.
- Related resources
- Hugging Face embeddings documentation — Embeddings and similarity
Stage 3: Prompting and output contracts
Design prompts with explicit output contracts and test them systematically.
A prompt without an output contract produces unparseable results downstream.
- What you learn
- Prompt design.
- Output contracts.
- Output validation.
- Few-shot examples.
- What you should build
- Build a prompt that returns a typed JSON object and validate the output against a schema.
- Ready when
- You can build a prompt with a schema and validate its output programmatically.
- Common mistake
- Iterating on prompts by feel without an evaluation set.
- Acceptance checks
- Build a prompt with a schema and validate its output programmatically.
- Related resources
- OpenAI prompt engineering guide — Prompt design and output structuring
Stage 4: Evaluate generation before adding complexity
Build an evaluation set and measure generation quality before adding retrieval or adaptation.
You cannot improve what you have not measured; adding components without a baseline hides regressions.
- What you learn
- Evaluation set.
- Rubrics and judges.
- Generation metrics.
- What you should build
- Create an evaluation set and a script that scores generations against rubrics.
- Ready when
- You can run an evaluation script and report a score that detects a regression.
- Common mistake
- Adding RAG or fine-tuning before establishing a prompt-only evaluation baseline.
- Acceptance checks
- Run an evaluation script and report a score that detects a regression.
- Related resources
- LangSmith evaluation guide — Datasets, evaluators and regression testing
Stage 5: Retrieval and grounded answers
Index documents, retrieve relevant passages and ground answers with citations.
Retrieval reduces hallucination for knowledge-bound tasks and makes answers auditable.
- What you learn
- Document indexing.
- Retrieval and ranking.
- Grounding and citations.
- RAG evaluation.
- What you should build
- Add a retrieval step that supplies cited passages and compare evaluation with and without retrieval.
- Ready when
- You can add retrieval and show an evaluation delta versus the prompt-only baseline.
- Common mistake
- Dumping raw chunks into the prompt without ranking or citations.
- Acceptance checks
- Add retrieval and show an evaluation delta versus the prompt-only baseline.
- Related resources
- LangChain retrieval documentation — Embeddings, vector stores and retrieval patterns
Stage 6: Conversation and context management
Maintain conversation state, manage context windows and isolate user sessions.
Unmanaged context degrades quality and leaks state between users.
- What you learn
- Conversation state.
- Context window management.
- Session isolation.
- Memory and summarization.
- What you should build
- Build a multi-turn chat with session isolation and a context-window management strategy.
- Ready when
- You can maintain multi-turn context with isolation and a documented window strategy.
- Common mistake
- Appending every turn until the context window overflows.
- Acceptance checks
- Maintain multi-turn context with isolation and a documented window strategy.
- Related resources
- OpenAI API documentation — Conversation and streaming APIs
Stage 7: Model adaptation when evaluation supports it
Choose fine-tuning, LoRA or instruction tuning only when evaluation justifies it.
Adaptation is expensive and can make a model worse if the data or evaluation is weak.
- What you learn
- When to adapt.
- LoRA and parameter-efficient methods.
- Adaptation data.
- Adaptation evaluation.
- What you should build
- Run a small adaptation experiment and compare it with the prompt-only baseline on the evaluation set.
- Ready when
- You can run an adaptation experiment and report whether it beats the baseline on the eval set.
- Common mistake
- Fine-tuning before proving retrieval or prompting cannot solve the problem.
- Acceptance checks
- Run an adaptation experiment and report whether it beats the baseline on the eval set.
- Related resources
- Hugging Face PEFT documentation — Parameter-efficient fine-tuning
Stage 8: Choose a multimodal specialization
Branch into image, audio or multimodal work according to your goal.
Most practitioners should go deep on text first; other modalities are optional branches.
- What you learn
- Text specialization.
- Image specialization.
- Audio specialization.
- Multimodal integration.
- What you should build
- Complete a small project in your chosen modality with an evaluation.
- Ready when
- You can ship a small project in your chosen modality with a defensible evaluation.
- Common mistake
- Starting multimodal work before mastering text-based generation and evaluation.
- Acceptance checks
- Ship a small project in your chosen modality with a defensible evaluation.
- Related resources
- Hugging Face diffusion course — Image generation models
Stage 1: Programming, data and model foundations
Python, data handling and the basic vocabulary of generative models.
Generative applications are software; you cannot evaluate them without engineering fundamentals.
- What you learn
- Python and data handling.
- Tokenizers.
- Generative model vocabulary.
- Model APIs.
- What you should build
- Build a script that loads a pretrained tokenizer and encodes text.
- Ready when
- You can load a tokenizer and explain what tokenization does to input text.
- Common mistake
- Skipping programming fundamentals to jump straight into prompt engineering.
- Acceptance checks
- Load a tokenizer and explain what tokenization does to input text.
- Related resources
- Hugging Face LLM Course — Tokenizers and pretrained models
Stage 2: Tokens, embeddings and generative models
Understand how tokens become embeddings and how generative models produce outputs.
Knowing how models represent inputs helps you debug failures and choose retrieval strategies.
- What you learn
- Tokens and context windows.
- Embeddings.
- Generative model families.
- Sampling and decoding.
- What you should build
- Inspect embeddings for similar and dissimilar sentences and report the distances.
- Ready when
- You can inspect embeddings and explain why similar sentences have closer vectors.
- Common mistake
- Treating embeddings as magic numbers without understanding similarity.
- Acceptance checks
- Inspect embeddings and explain why similar sentences have closer vectors.
- Related resources
- Hugging Face embeddings documentation — Embeddings and similarity
Stage 3: Prompting and output contracts
Design prompts with explicit output contracts and test them systematically.
A prompt without an output contract produces unparseable results downstream.
- What you learn
- Prompt design.
- Output contracts.
- Output validation.
- Few-shot examples.
- What you should build
- Build a prompt that returns a typed JSON object and validate the output against a schema.
- Ready when
- You can build a prompt with a schema and validate its output programmatically.
- Common mistake
- Iterating on prompts by feel without an evaluation set.
- Acceptance checks
- Build a prompt with a schema and validate its output programmatically.
- Related resources
- OpenAI prompt engineering guide — Prompt design and output structuring
Stage 4: Evaluate generation before adding complexity
Build an evaluation set and measure generation quality before adding retrieval or adaptation.
You cannot improve what you have not measured; adding components without a baseline hides regressions.
- What you learn
- Evaluation set.
- Rubrics and judges.
- Generation metrics.
- What you should build
- Create an evaluation set and a script that scores generations against rubrics.
- Ready when
- You can run an evaluation script and report a score that detects a regression.
- Common mistake
- Adding RAG or fine-tuning before establishing a prompt-only evaluation baseline.
- Acceptance checks
- Run an evaluation script and report a score that detects a regression.
- Related resources
- LangSmith evaluation guide — Datasets, evaluators and regression testing
Stage 5: Retrieval and grounded answers
Index documents, retrieve relevant passages and ground answers with citations.
Retrieval reduces hallucination for knowledge-bound tasks and makes answers auditable.
- What you learn
- Document indexing.
- Retrieval and ranking.
- Grounding and citations.
- RAG evaluation.
- What you should build
- Add a retrieval step that supplies cited passages and compare evaluation with and without retrieval.
- Ready when
- You can add retrieval and show an evaluation delta versus the prompt-only baseline.
- Common mistake
- Dumping raw chunks into the prompt without ranking or citations.
- Acceptance checks
- Add retrieval and show an evaluation delta versus the prompt-only baseline.
- Related resources
- LangChain retrieval documentation — Embeddings, vector stores and retrieval patterns
Stage 6: Conversation and context management
Maintain conversation state, manage context windows and isolate user sessions.
Unmanaged context degrades quality and leaks state between users.
- What you learn
- Conversation state.
- Context window management.
- Session isolation.
- Memory and summarization.
- What you should build
- Build a multi-turn chat with session isolation and a context-window management strategy.
- Ready when
- You can maintain multi-turn context with isolation and a documented window strategy.
- Common mistake
- Appending every turn until the context window overflows.
- Acceptance checks
- Maintain multi-turn context with isolation and a documented window strategy.
- Related resources
- OpenAI API documentation — Conversation and streaming APIs
Stage 7: Model adaptation when evaluation supports it
Choose fine-tuning, LoRA or instruction tuning only when evaluation justifies it.
Adaptation is expensive and can make a model worse if the data or evaluation is weak.
- What you learn
- When to adapt.
- LoRA and parameter-efficient methods.
- Adaptation data.
- Adaptation evaluation.
- What you should build
- Run a small adaptation experiment and compare it with the prompt-only baseline on the evaluation set.
- Ready when
- You can run an adaptation experiment and report whether it beats the baseline on the eval set.
- Common mistake
- Fine-tuning before proving retrieval or prompting cannot solve the problem.
- Acceptance checks
- Run an adaptation experiment and report whether it beats the baseline on the eval set.
- Related resources
- Hugging Face PEFT documentation — Parameter-efficient fine-tuning
Stage 8: Choose a multimodal specialization
Branch into image, audio or multimodal work according to your goal.
Most practitioners should go deep on text first; other modalities are optional branches.
- What you learn
- Text specialization.
- Image specialization.
- Audio specialization.
- Multimodal integration.
- What you should build
- Complete a small project in your chosen modality with an evaluation.
- Ready when
- You can ship a small project in your chosen modality with a defensible evaluation.
- Common mistake
- Starting multimodal work before mastering text-based generation and evaluation.
- Acceptance checks
- Ship a small project in your chosen modality with a defensible evaluation.
- Related resources
- Hugging Face diffusion course — Image generation models
From roadmap to production
Build production Generative AI systems with instructor feedback
You have the framework. The View the Generative AI syllabus adds what self-study cannot: live instruction, instructor-reviewed labs, production deployment drills and a capstone that proves you can ship and operate — not just understand.
Fees, schedules and enrolment details are on the course page. No placement, salary or outcome is guaranteed.
Starting Point
Choose your starting point
Software developer: You already know Python, APIs, testing and deployment. Your gap is model behaviour, retrieval and evaluation. Start at Stage 2 (tokens, embeddings and models) and move forward. You can likely skip Stage 1 if you are comfortable with Python and data handling.
ML or data practitioner: You understand training, evaluation and data preparation. Your gap is GenAI-specific concepts — prompting, retrieval, adaptation and multimodal. Start at Stage 3 (prompting and output contracts) if you already understand embeddings, or at Stage 2 if you need to refresh how generative models differ from discriminative ones.
Learner missing coding or data foundations: If you do not yet know Python functions, modules and virtual environments, start there first. This roadmap assumes basic Python proficiency. Free resources like the Python tutorial and Hugging Face course can help. Do not jump to prompt engineering before you can write and run Python code.
Building Evidence
How to turn study into project evidence
As you work through the stages, retain the evidence of your learning. For each exercise: save the baseline (what a simpler approach achieved), the tests (specific cases with expected outcomes), the failed examples (where the system broke), the design decisions (why you chose this approach), and the revisions (what you changed and what happened).
This evidence becomes your portfolio. A GitHub repository with a README, evaluation script and results table is more credible than a polished demo with no tests. For complete project briefs with evaluation criteria, see the Generative AI projects guide.
Sustainable Rhythm
Planning learning around a full-time job
A sustainable learning rhythm follows a cycle: learn one concept, implement it immediately, evaluate the result, and revise based on what the evaluation shows. This cycle is more effective than binge-watching videos on weekends without implementation.
An illustrative self-study pattern: weekday evenings (45–60 minutes) for learning and implementation, weekend mornings (2–3 hours) for evaluation, revision and documentation. This is an illustrative pattern — adjust it to your schedule and energy. The key is consistency, not intensity. Do not invent a completion deadline — progress depends on your starting point, available time and the complexity of projects you attempt.
Structured Learning
When a structured course can help
Independent learning works well if you have strong prerequisites, can scope and evaluate your own projects, have access to feedback from colleagues or community, and maintain consistent study habits. Many practitioners build successful GenAI skills this way.
A structured course may help when you have difficulty choosing a learning sequence, are uncertain whether your project approach is correct, keep making the same technical mistakes, or need structured feedback from someone who can inspect your work. If you want to work through a structured sequence with guided projects and review, compare the live Generative AI course with this roadmap.
Capstone
Build an evidence-based document assistant
Build a retrieval-grounded assistant over a small document set with an evaluation set, output contracts, session isolation and a documented comparison of prompt-only versus retrieval-augmented results. Try the free evaluation lesson first to practise the testing pattern.
Training alignment
How this roadmap aligns with SCAI's Generative AI course
This roadmap is free and self-paced. SCAI's Generative AI course covers prompting, retrieval, evaluation and adaptation with live instruction and guided labs.
The course adds what the roadmap cannot: instructor review of your evaluation datasets and retrieval design, plus guided adaptation experiments with feedback. If you prefer independent study, this roadmap gives you the full framework.
What to read next
What to read next
For application delivery with APIs, data and deployment, see the AI Developer roadmap. For controlled agent patterns with tool permissions and evaluation, see the Agentic AI roadmap. For operating LLM applications in production, see the LLMOps roadmap. For help choosing a course, see the curriculum evaluation guide.
Related learning
- Continue to the AI Developer roadmapTo turn generative AI knowledge into shipping applications.
- Continue to the Agentic AI roadmapWhen you want tool-using, autonomous agent systems.
- Continue to the LLMOps roadmapTo operate and govern LLM systems in production.
- Deepen LLM model engineering knowledgeArchitecture, fine-tuning, alignment and evaluation in depth.
- Compare Generative AI, AI Developer and Agentic AIWhere each path focuses across the generative AI stack.
- Compare the Generative AI and Agentic AI coursesGenerative model systems versus autonomous agents.
- Compare RAG and fine-tuningGrounding versus adaptation — a core generative AI decision.
FAQ
Generative AI Roadmap — Frequently Asked Questions
Direct answers for engineers building generative AI systems.
Do I need to train a model from scratch?
No. Most generative AI work uses pretrained models with prompting, retrieval or parameter-efficient adaptation.
What should I learn first: RAG or fine-tuning?
Learn evaluation first, then RAG. Fine-tune only when evaluation proves prompting and retrieval cannot close the gap.
Is prompt engineering a complete skill?
It is one skill. Without output validation and evaluation, prompt engineering is not production-ready.
Do I need to learn multimodal AI?
Only if your target application requires it. Master text-based generation and evaluation first.
How do I evaluate a generative application?
Build an evaluation set, score outputs with rubrics or model-based judges, and track regressions across changes.