Available Hire Me
← All Writing Architecture

An Enterprise AI Platform for a UK Housebuilder — What the Capability Actually Is

Why an enterprise AI capability is a platform, not a chatbot: data foundations, a model gateway, evaluation, governance, and a sequenced first release.

I am in early discussions with a UK housebuilder about building out an enterprise-wide AI platform capability. Nothing is signed, so this is not a case study. It is the shape of the problem as I see it, and the architecture I would argue for before anyone writes a prompt.

The distinction that matters at the start is between a capability and a demo. A demo proves a model can answer a question over a folder of PDFs. A capability lets a hundred people across sales, technical, and customer care ask questions over the company’s actual document estate, on a Monday morning, with an audit trail and a cost per answer the finance director will accept.

Those are different projects.

What a housebuilder actually holds

A housebuilder is a document-heavy, process-heavy business with a long tail of semi-structured knowledge:

  • Land and planning — site appraisals, planning applications, condition discharges, correspondence with local authorities.
  • Technical — drawings, specifications, engineering reports, building-control and warranty submissions.
  • Sales — development availability, reservations, part-exchange, options and upgrades, CRM history.
  • Delivery — subcontractor packages, programmes, inspection records, snagging.
  • Customer care — warranty tickets, defect history, remediation evidence.

Most of it is unstructured, versioned by filename convention rather than by a system, and owned by people rather than by a schema. That is the raw material. It is also the reason a generic “chat with your documents” product disappoints: the value is not in retrieving a paragraph, it is in knowing which revision is current, which site it belongs to, and whether the answer is allowed to be given.

Five layers, one paved road

An enterprise-wide capability is a platform with a small number of shared components and a large number of thin use cases on top. I would structure it in five layers.

1. Data foundation

Before retrieval there has to be a defensible answer to “what is the corpus?” That means ingestion contracts, document identity, revision lineage, access classification, and retention. The housebuilder’s document management system is the system of record; the platform should not become a second one.

The output of this layer is not an index. It is a catalog: every chunk traceable to a source document, a revision, a site, and an access group. Without that, every later answer is unauditable.

2. Retrieval and grounding

Retrieval is where most demos are won and most platforms fail. The naive approach — embed everything, take the top-k — degrades quietly: near-duplicate revisions compete, tables lose their headers, and a confident answer cites a superseded drawing.

The practical fixes are unglamorous. Chunk on document structure rather than character count. Keep metadata filters first-class, so “this site, this revision, this document type” narrows the candidate set before similarity runs. Treat tables as structured data, not text. And always return the citation alongside the answer, because a user who cannot check the source will not trust the system twice.

3. Model gateway

Every model call goes through one gateway. That gateway owns credentials, model selection, rate limits, retries, token accounting, prompt and response logging, and the policy about which data classes may go to which provider.

This is the layer that stops the estate from becoming a set of unmanaged API keys in departmental scripts. It is also the layer that makes model choice reversible. Models will change; the gateway is the seam that lets them change without rewriting every use case.

4. Orchestration and tools

The useful use cases are rarely pure question-answering. They are workflows: classify an inbound customer-care email, pull the relevant warranty history, draft a response, route it for approval. That means tool calling against line-of-business systems, with the same discipline as any other integration — idempotency, timeouts, circuit breakers, and an audit record of what the model asked for and what it received.

On AWS I would keep this boring: ECS Fargate or Lambda for the services, SQS or Kafka for the asynchronous steps, CDK for the infrastructure, and a relational store for the workflow state that has to be queryable by humans. The AI is a component inside a system, not the system.

5. Evaluation and observability

This is the layer that separates a capability from a liability, and it is the one most commonly deferred.

An evaluation set is a curated set of real questions with known-good answers and known-bad answers. It is owned by the business, versioned like code, and run on every prompt, retrieval, or model change. Without it, every change is a vibe check, and regressions are discovered by a user who has lost confidence.

Alongside it: per-request traces, retrieval hit rates, groundedness checks, latency percentiles, token cost per workflow, and a feedback channel that feeds new cases back into the evaluation set. If the platform cannot say what it cost and how often it was right, it is not ready for enterprise-wide use.

Governance is a product feature

A housebuilder operates in a regulated, safety-adjacent environment. Answers about warranties, building control, and planning conditions carry consequences. So the platform needs explicit rules about:

  • Which use cases may answer and which must draft for a human. Customer care and technical queries start as drafting assistants.
  • Which data may leave the estate, and under what contractual terms.
  • What the system is allowed to claim. A grounded answer cites a document; an ungrounded one says it does not know.
  • How long prompts and responses are retained, and who can read them.
  • How a wrong answer is corrected, including the ability to withdraw a workflow.

None of that is exotic. It is the same governance you would apply to any system that touches customers and compliance. The difference is that an LLM makes it easy to ship something impressive before those questions are answered.

The sequencing I would argue for

Enterprise-wide does not mean big-bang. It means the first release establishes the paved road that later use cases inherit.

  1. Pick one workflow with a measurable outcome. Document-heavy, low-risk, high-volume. Technical document search or customer-care drafting are the usual candidates.
  2. Build the evaluation set before the feature. If the business cannot define a good answer, the use case is not ready.
  3. Ship the platform skeleton with it — ingestion catalog, gateway, tracing, cost accounting. Thin, but real.
  4. Prove the economics. Measure time saved, escalation reduction, and cost per interaction. A capability that cannot justify its run cost will not survive its second budget cycle.
  5. Then broaden by template. Each new use case reuses the catalog, the gateway, the evaluation harness, and the governance rules.

The failure mode is the inverse: twelve departmental pilots, twelve document stores, no shared evaluation, and a board asking why the AI programme has no number attached to it.

What I would want to know before designing it

The questions I would put to the business first are not about models:

  • Which decisions are we trying to make faster or better, and who owns them today?
  • Which documents are authoritative, and how is a revision proven current?
  • What is the cost of a wrong answer, and who carries it?
  • Which systems hold the workflow state that the AI must read and write?
  • Who will own the evaluation set after the consultants leave?

If those have answers, the architecture is tractable. If they do not, the model choice is premature.

I have spent my career building systems where correctness and auditability matter — trading platforms, national-scale government services, and now gilt analytics. An AI platform for a housebuilder is the same discipline applied to a different corpus: make the data traceable, make the behaviour testable, and make the cost visible.

If you are working through the same set of decisions, get in touch — I am happy to compare notes on the platform shape before you commit to a vendor.

Samuel Jackson

Samuel Jackson

Senior Java Back End Developer & Contractor

Senior Java Back End Developer — Betfair Exchange API specialist, Spring Boot, AWS, and event-driven architecture. 25+ years delivering high-performance systems across betting, finance, energy, retail, and government. Available for Java contracting.