Skip to content
Linear Horizon Training

Ready-made course · 2 days · Intermediate

Building Applications with Generative AI

A two-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.

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.

Who it is for
Software engineers and technical teams who will implement AI-powered products or internal applications.
Before you start
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.

You will be able to

  • Design an application architecture that isolates model access, retrieval, tools and user-facing behaviour.
  • Implement prompt design, structured outputs and tool use inside a real application rather than a notebook.
  • Add retrieval and memory with explicit context construction and citations.
  • Handle model, retrieval and tool failures without losing the user or the audit trail.
  • Implement guardrails, evaluation and tests around the paths that matter.
  • Measure and control cost and latency as part of the design.
  • Deploy a working end-to-end application with a production-shaped boundary.

Modules

8 quarter-day modules. Each one can go into a custom course on its own.

  1. Architecture of an LLM application

    • Where the model sits: service boundaries, gateways and the rest of the stack.
    • Synchronous, streaming and background patterns.
    • Model access through providers, cloud platforms or self-hosting.
    • Failure handling: timeouts, retries, fallbacks and degraded modes.
  2. Working with LLM APIs

    • API keys and authentication.
    • Sending and receiving requests, structured JSON and streaming.
    • Managing context and conversation state.
    • Cost and token management.
    • Enough Python to understand and change the examples. All code is supplied, with starting points and worked solutions.
  3. Prompts and schemas as tested interfaces

    • Prompts as code: instructions, examples, constraints and versioning.
    • Structured outputs and JSON Schema: a request, not a guarantee.
    • Separating trusted instructions from untrusted input.
    • Lab: write a prompt with tests, then break it with realistic inputs.
  4. Context engineering and memory

    • What goes into context, what is retrieved and what is left out.
    • Long conversations: truncation, summaries and their failure modes.
    • Short-term and long-term memory, and when to forget.
    • Prompt caching and its effect on cost and latency.
  5. RAG and proprietary knowledge

    • Using your specifications, documentation and knowledge bases with an LLM.
    • Embeddings, vector databases and hybrid search.
    • Turning documentation into FAQs to improve retrieval.
    • Citations and source grounding.
    • Updating knowledge without retraining a model, and reducing hallucination.
  6. Agents and tool calling

    • What an agent actually is, and when we need one.
    • Function and tool calling.
    • Letting an LLM work with your existing APIs and software.
    • ReAct and Reflection concepts where useful.
    • "Agentic first turns": the assistant opens the conversation with relevant context.
    • When a conventional workflow is better than an autonomous agent.
  7. Security and commercial deployment

    • Protecting proprietary and customer data.
    • Data retention and privacy.
    • Authentication, permissions and access control.
    • Customer-facing versus internal AI.
    • Guardrails and human decision boundaries.
  8. Evaluation and production

    • How to test objectively whether an AI solution works, using golden test sets and LLM-assisted scoring.
    • Measuring accuracy and reliability.
    • Logging, observability and human-in-the-loop.
    • Cost and performance monitoring.
    • Knowing when something is safe enough for production or customer use.

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.

You take away

  • 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

Combine it with

Contact