Audience
- Software developers moving into applied AI delivery.
- Technical founders developing an AI product beyond its initial prototype.
- Engineers supporting AI services within an existing application environment.
AI & technology
AI Engineering
Move from an AI prototype towards a dependable, maintainable application.
Learning with a practical purpose.
Learn the engineering work that sits between an appealing AI demonstration and a service that can be operated responsibly. This module focuses on a small AI-powered application with clear requirements, a testable architecture and visible operating behaviour. You will examine the trade-offs between output quality, response time, cost and maintainability.
The practical thread is an evaluated document-assistance service. You will build an API, manage configuration and secrets, define behavioural tests and introduce monitoring that helps diagnose real failures. The emphasis is disciplined development and release decisions: knowing what has been tested, what remains uncertain and what evidence is needed before expanding the application’s use.
Live onlineTeaching through Kent Business College, UK
2 hoursOne live session each teaching week
14 sessionsA semester for each module
28 live hoursPer module, plus independent study
The outline below is a 14-session online module, with one two-hour live session each teaching week. Reading weeks, breaks and additional activities follow the agreed cohort calendar. The cohort syllabus, full route, dates, fees, independent study and assessment requirements are confirmed before enrolment.
Who this module is designed for.
Starting knowledge and preparation
- Working Python or JavaScript skills and experience with APIs.
- Basic testing, Git and relational-database knowledge.
- Experience building a small application or completing an equivalent introductory module.
What you will work towards.
- Specify a bounded AI service with measurable functional and quality requirements.
- Implement a maintainable architecture with controlled model and data access.
- Build repeatable evaluations and regression checks for important behaviours.
- Measure latency, resource use and common failure conditions.
- Prepare a release, rollback and support plan based on observed application performance.
Explore the 14-session learning plan.
Explore the focus and practical output of each teaching session. Open individual sessions below, or expand the complete plan.
Session 01 Defining the service and its users
Translate a business need into request types, expected outputs and quality requirements that can be tested.
Practical output: A service specification and acceptance plan.
Session 02 Architecture and separation of responsibilities
Separate interface, business logic, model calls and storage so that each part can be changed deliberately.
Practical output: An application architecture and repository structure.
Session 03 Model interfaces and structured outputs
Implement a model adapter and validate responses before they are used by another application component.
Practical output: A tested model-access layer.
Session 04 Configuration and secret handling
Manage environment settings, credentials and deployment differences without exposing sensitive values in browser code or logs.
Practical output: A configuration and secret-handling design.
Session 05 Data contracts and persistence
Define request records, outputs and feedback data with validation and a clear ownership model.
Practical output: A service schema and persistence layer.
Session 06 Building a useful evaluation set
Create representative requests and difficult cases with explicit judgements about acceptable and unacceptable results.
Practical output: A versioned evaluation dataset.
Session 07 Behavioural tests and regression checks
Turn evaluation cases into repeatable checks and distinguish deterministic validation from judgement-based output assessment.
Practical output: An automated and human-review test plan.
Session 08 Reliability around model calls
Handle timeouts, unsuccessful responses and unavailable dependencies while preserving a useful experience for the user.
Practical output: A failure-handling implementation.
Session 09 Latency, cost and caching choices
Measure response times and resource use, then evaluate whether batching, caching or simpler processing is appropriate.
Practical output: A measured performance comparison.
Session 10 Access control and untrusted inputs
Enforce permissions before data access and test how the service treats user content and retrieved instructions.
Practical output: An access and input-boundary test report.
Session 11 Observability and feedback loops
Record useful traces and quality signals while avoiding unnecessary exposure of sensitive request content.
Practical output: A monitoring dashboard or diagnostic report.
Session 12 Releases, rollback and incident response
Plan deployment checks, a reversible release and a practical response when output quality or availability declines.
Practical output: A release and incident runbook.
Session 13 Service integration and readiness review
Integrate the application and test its critical journeys against the original acceptance and evaluation plan.
Practical output: An evaluated release candidate.
Session 14 Demonstration and engineering handover
Present the service, operating evidence and unresolved risks, then recommend a proportionate next development stage.
Practical output: A final demonstration and engineering handover.
Apply the learning
An evaluated document-assistance service
Build an API-backed service that performs one bounded document task, such as extracting approved fields or preparing a reviewable summary. Include validation, authenticated access and a repeatable evaluation set. Your release recommendation should be based on observed quality and operating behaviour rather than the success of a single demonstration.
Your project evidence can include
- A runnable application and documented API contract.
- Evaluation cases, test results and performance measurements.
- A release checklist, rollback procedure and support runbook.
Use anonymised, public or suitable synthetic material where workplace information is confidential. The issued assessment brief confirms the required evidence.
Assessment, feedback and certification.
- Engineering exercises assess interfaces, validation and reproducible testing.
- The integrated service is reviewed against declared quality and operating criteria.
- A technical presentation explains trade-offs, monitoring choices and the remaining work before wider use.
Teaching and the relevant course certificate are provided through Kent Business College in the UK. Completion requirements are set out in the module information; attendance alone should not be assumed to meet every assessment requirement.
Questions worth asking.
Will I train a foundation model?
No. The module focuses on engineering applications around available models and data, including the evaluation and operational work needed to support them.
Is the final service certified for production?
No. You produce a tested learning implementation and a readiness assessment. An organisation must validate its own requirements before operational deployment.
How technical is the course?
It assumes you can already build and debug a small application. Beginners should first develop coding, API and database foundations.