Intermediate · 2–3 days
Building Applications with Generative AI
A two-to-three-day build course for software engineers: take an AI-powered application from architecture through RAG, tools, evaluation and deployment, ending with an end-to-end system.
2–3 days · Intermediate · AI Engineering · Software engineers and technical teams
Overview
Isolated demos hide the parts of an AI application that determine whether it can be shipped: application structure, error handling, evaluation, cost, latency and the boundary between the model and the rest of the system. This course is organised around building one application, not around a sequence of disconnected labs.
You start with architecture and model APIs, then add prompt design, structured outputs, tools, context and retrieval. Memory, agents, guardrails and testing are introduced as the application becomes capable enough to need them. Cost, latency and deployment are treated as design constraints from the middle of the course, not as a closing discussion.
The course is practical and progressive. Each module extends the same system. The final project is an end-to-end application with a retrieval path, tools, evaluation and a deployment shape that could be handed to a team.
You leave with a working application and a clearer sense of which patterns belong in production and which only belong in a prototype.
Audience
Software engineers and technical teams who will implement AI-powered products or internal applications.
Prerequisites
Professional software development experience. You should be able to build and run a small web or backend application. Prior LLM experience is helpful but not required.
Duration
2–3 days
Two days covers a complete application. Three days adds more depth on agents, evaluation and production hardening.
Learning outcomes
- 01
Design an application architecture that isolates model access, retrieval, tools and user-facing behaviour.
- 02
Implement prompt design, structured outputs and tool use inside a real application rather than a notebook.
- 03
Add retrieval and memory with explicit context construction and citations.
- 04
Handle model, retrieval and tool failures without losing the user or the audit trail.
- 05
Implement guardrails, evaluation and tests around the paths that matter.
- 06
Measure and control cost and latency as part of the design.
- 07
Deploy a working end-to-end application with a production-shaped boundary.
Outline
- 01
Application architecture and model access
- Separating UI, orchestration, model I/O, retrieval and tools.
- Model APIs, authentication, environment configuration and provider abstraction.
- Prompt design and structured outputs as application contracts.
- Build: stand up the application skeleton and a first constrained model call.
- 02
Context, retrieval and memory
- What belongs in the prompt, what belongs in retrieval, and what belongs in application state.
- RAG: ingestion, retrieval, citations and refusal when evidence is missing.
- Conversational context and memory without pretending the model remembers.
- Build: add a knowledge path and inspect what was actually retrieved.
- 03
Tools, agents and error handling
- Tools as application capabilities with schemas, permissions and timeouts.
- When an agent loop is justified, and when an explicit workflow is safer.
- Error handling: empty retrieval, invalid tool arguments, timeouts and partial success.
- Build: add a tool and a controlled agent or workflow path.
- 04
Evaluation, guardrails and deployment
- Golden cases, output checks, groundedness and regression when prompts change.
- Guardrails: input handling, output handling, and blocking unsafe tool use.
- Cost, latency, caching and what to measure in production.
- Deployment: configuration, secrets, logging and a service that can be operated.
- Final project: complete the application and run it against an evaluation set.
Practical work
You progressively build one application across the course. Typical shape: a domain assistant or workflow tool with retrieval, at least one tool, evaluation and a deployable service. The final session is an end-to-end project rather than a presentation recap.
Takeaways
- A working end-to-end application
- Architecture patterns for model access, RAG, tools and guardrails
- Evaluation cases and a first regression set
- A deployment and operations checklist
Delivery
Cognitecta delivers private corporate training, on-site or as remote live training. Courses can be run as published, or adapted to your organisation’s stack, domain and experience level.
Instructor
Nicholas Johnson, AI architect and software engineer. He has a degree in Artificial Intelligence and around twenty years of professional technology training, including hundreds of courses for engineering teams and large organisations. About.
Related courses
3 days · Intermediate
AI Engineering for Software Developers
A three-day programme for professional software engineers: how to build real applications with modern AI, from model APIs and RAG through agents, evaluation and production patterns.
1 day · Intermediate
Evaluating and Testing LLM Applications
A one-day course on evaluating non-deterministic systems: golden datasets, semantic checks, LLM-as-judge, retrieval and agent evaluation, and the pipeline that keeps quality from drifting.
1 day · Intermediate
Securing Generative AI Applications
A one-day security course for developers, security engineers and architects: the specific risks created by LLM applications, and the controls that actually reduce them.