A job posting for a generative AI engineer at a mid-sized fintech lists fourteen requirements. Nine of them are ordinary software engineering: version control, API design, containers, testing, a bit of SQL. Two are about calling model APIs. Three are about evaluation, cost control, and stopping a retrieval pipeline from quietly serving last quarter’s policy documents to customers. Most courses spend roughly 80% of their time on the two.
That gap explains a familiar story. Someone finishes a 30-hour program, builds a chatbot that works on their laptop, and then freezes in an interview when asked how they’d catch a regression after swapping models. The certificate is real. The skill isn’t yet.
What a Generative AI Engineer Actually Does All Day
Generative AI engineers are not research scientists. They build products on top of models they don’t own, can’t retrain cheaply, and don’t fully control. The work is closer to plumbing than to magic.
A realistic Tuesday: adjusting chunk sizes because the summariser keeps missing tables, writing twenty new eval cases after a support ticket about hallucinated refund policies, shaving a p95 latency from 4.2 seconds down to 1.9 by switching from a chatty chain to a single structured call, then explaining to finance why last month’s token bill tripled.
The rough split of a junior role looks like this: 60–70% conventional software engineering, 20% LLM-specific integration, 10% experimentation. Any generative AI engineering course that inverts those numbers is selling excitement rather than employability.
The Skills a Serious Course Has to Cover
Real engineering fundamentals, not a warm-up module
Async Python, HTTP, JSON schema validation, Git workflows, Docker, basic observability. If a program treats these as optional preamble, its capstone will be a notebook and nothing else. If you’re coming from a non-technical background, start with a grounding in AI fundamentals explained without the jargon before paying for anything advanced.
Model APIs beyond the happy path
Everyone can write a first call. Fewer can handle streaming responses, tool calling, forced JSON output, retries with exponential backoff, rate-limit handling, and token accounting. Those are the parts that break in production, and they’re the parts worth learning.
Retrieval and context management
Chunking strategy, embeddings, hybrid search, reranking, and the trade-off nobody mentions in marketing copy: stuffing an entire document into the context window costs money and dilutes the model’s attention. Good courses show you a side-by-side comparison rather than asserting one answer.
Evaluation as a first-class discipline
This is the module to check for. You want golden datasets, LLM-as-judge with human spot checks, and a regression suite that runs on every prompt change. A course that gives evaluation twenty minutes in week nine is teaching vibes-based development.
Cost, latency, and deployment
Prompt caching, semantic caching, batching, distillation to a smaller model for narrow tasks, and dashboards that show dollars per request. Practical stuff, and rarely taught well.
Here’s a concrete checklist. By the end of a program you should have produced:
- A retrieval-augmented app answering questions over 500+ documents, with citations that actually resolve
- An eval suite with 50+ labelled examples and a pass threshold that gates deployment
- A cost and latency dashboard tracking tokens and dollars per request
- One distilled or fine-tuned small model matching a larger model on a single narrow task
- A deployed endpoint with authentication, structured logging, and a rate limiter
How to Judge a Program Before You Pay
Ignore the syllabus length. Thirty hours of video is not a curriculum, it’s a video library. Look instead at whether the instructor has shipped something that handles real traffic, and whether the course repository has issues and pull requests from students rather than just a static GitHub page.
Courses that survive this filter tend to look a certain way. There’s a genuine method for telling a good course from a long tutorial: check whether each module ends in an artefact you can show someone, or merely in a quiz. A useful comparison of generative AI courses ranked by what you’ll actually build is worth ten minutes before you commit several hundred pounds.
Red flags that show up again and again:
- Six hours on prompt engineering, twenty minutes on evaluation
- No mention of cost, latency, or failure modes anywhere in the outline
- Capstone is a chatbot over a single PDF
- Instructor’s last shipped product predates the current model generation
- The landing page leads with the certificate rather than the portfolio
Free, Paid, and What the Certificate Is Actually Worth
Plenty of reputable material costs nothing. It’s worth knowing what free AI certificate programs genuinely include for $0, because the answer is usually lectures and a PDF, not code review.
What you’re really buying with a paid program is structure, a deadline, and someone who will tell you your retrieval pipeline is wrong. That has real value if you’re the type who abandons self-directed learning in week three. It has none if you’re already shipping side projects. And on credentials specifically, there’s a sensible breakdown of which AI certifications are worth paying for that separates the recruiter-recognised from the decorative.
Build Three Things Nobody Can Fake
Portfolio projects beat certificates almost every time, but only if they’re specific. “AI chatbot using LangChain” reads as a tutorial re-run. These read differently:
- A document assistant for a real charity’s messy policy archive, with an eval set built from questions their staff actually asked
- A support-ticket triager that cut a fake queue’s handle time in half, with the before/after numbers written up
- A cost-reduced rewrite of someone else’s public demo, dropping per-request spend by 70% through caching and a smaller model
Each one gives you something to talk about for twenty minutes in an interview: what broke, what you measured, what you’d do differently.
A Ten-Week Plan That Beats Most Paid Cohorts
If you want to start this week without spending anything, this sequence works. Weeks one to two: rebuild your Python and API fundamentals by shipping a small service that calls a model and handles errors properly. Weeks three to four: build retrieval over 500 real documents and measure answer quality by hand on 30 questions. Weeks five to six: turn those 30 questions into an automated eval suite and watch it catch you breaking things. Weeks seven to eight: attack cost and latency, then document the before and after. Weeks nine to ten: deploy with logging and auth, write a short technical post about the trade-offs you hit, and put all of it in one repository.
Do that, and you’ll have something a generative AI engineering course promises but rarely delivers: evidence you can build, measure, and defend a system that other people depend on.