Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
The gap the demo hides
Why the impressive prototype is the start of the work, not the end
We do not have an office in Saudi Arabia
We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.
Every LLM project begins with the same encouraging moment: someone wires a prompt to a model, asks it something real, and gets an answer good enough to convince a room. That prototype is genuinely fast, and it is genuinely misleading, because it demonstrates the one part of the system that was never the hard part. The model already works. What does not yet exist is everything that makes it a product a business can stand behind — and that is where the timeline the demo suggested quietly triples.
The missing parts are unglamorous and decisive. There is no way yet to tell a good answer from a plausible wrong one at scale, so quality is a matter of opinion. There is nothing stopping the model from answering outside its remit, so a clever user can push it somewhere embarrassing. And the cost, invisible on a handful of demo queries, becomes a real number the moment thousands of users each send long prompts. Building those three — evaluation, guardrails, cost control — is the engagement. The prompt was the easy afternoon everyone remembers; this is the quarter nobody warned them about.
A request in production
What a request passes through before and after the model sees it
In a demo a request goes straight to the model and straight back. In a product it passes through checks on the way in and the way out, and the model call is one step in the middle. The branch is what happens when a check fails.
A request passes through four steps — check the input, assemble context, call the model, check the output — with the model call in the middle and a branch that refuses, logs or escalates when a check fails.
- 01
Check what came in
The input is validated and screened before it reaches the model, so a malformed or hostile request is caught early rather than answered.
- 02
Give the model what it needs
The relevant context is assembled and the prompt constructed, so the model answers from the right material rather than from memory alone.
- 03
Call the model
The single step the demo showed — and the one that carries the least of the engineering risk in the finished product.
- 04
Check what came out
The answer is checked against the guardrails and, where it can be, against the source, before a customer ever sees it.
Refuse, log, or escalate
When an input or an output fails a check, the system declines or routes it rather than passing it through, and records why. A product without this branch is a demo that has been made available to the public, and it fails in front of the people it was meant to serve.
The scaffolding
The parts of an LLM product that are not the prompt
A prompt that works is a fraction of a product. These are the rest, grouped by the job each does, and skipping any group is how a demo fails to survive contact with real users.
Knowing if it is good
- Evaluation set
- Scoring on your cases
- Regression checks
- Human review loop
Keeping it in bounds
- Input screening
- Output guardrails
- Refusal behaviour
- Grounding to a source
Watching the economics
- Token accounting
- Latency budget
- Caching
- Model routing by cost
Running it in the open
- Logging
- Versioned prompts
- Rollback
- Usage monitoring
Our role
What we engineer and what stays your product decision
- 01
A way to measure "good"
We build an evaluation harness on your own cases so answer quality becomes a number your team can track, rather than an argument settled by whoever demos loudest.
- 02
Guardrails you define
We build the input and output checks that keep the model inside the remit you set, and design refusal as a normal behaviour rather than a failure to hide.
- 03
Cost you can see before it grows
We instrument the token and latency cost so the economics of a feature are known before it reaches everyone, not discovered on the invoice.
How good an answer has to be, and what the model is allowed to attempt, are product decisions only you can make; we build the evaluation, the guardrails and the cost control that turn those decisions into a system that holds them in production.
Common questions
What buyers ask
Why does an LLM product cost more than wiring up an API?+
Because wiring up the API is the part that was never expensive. The demo that impressed everyone is a prompt and a model call, and that genuinely takes an afternoon. The cost is in what a demo does not have: a way to measure whether answers are good enough at scale, guardrails that stop the model answering outside its remit, cost and latency control so thousands of users do not produce a surprise invoice, and the logging and versioning to operate it safely. None of that shows in a prototype, which is exactly why prototypes mislead on timeline. We separate the two explicitly at the start, so the plan reflects the product rather than the demo.
How do you measure whether the AI is giving good answers?+
With an evaluation set built from your own cases, not a general benchmark. We assemble a collection of real questions with known good answers, and score the system against it every time the prompt, the model or the context changes — so a change that improves one kind of answer and quietly breaks another is caught rather than shipped. Where quality is a matter of judgement we add a structured human review rather than pretending a single automatic score captures everything. The point is to turn "it seems good" into a number your team can watch move, because a system you cannot measure is one you are improving by opinion.
How do you keep the running cost of an LLM feature under control?+
By making cost a measured quantity from the first day rather than a line discovered on the invoice. Every request has a token cost that scales with the length of the prompt and the answer, and at demo volumes it is invisible while at production volumes it is one of your larger bills. We instrument it, so you can see what each feature costs per use, and then bring it down where it is worth doing: caching answers that repeat, trimming context that adds cost without adding quality, and routing simpler requests to a smaller, cheaper model while the hard ones go to a capable one. The goal is that the economics of a feature are a decision you make with numbers, not a surprise that arrives a month after launch.
In this cluster
Next step
Scope it with us
A build plan that separates the demo from the product, naming how quality is measured, how the model is guarded and how cost is kept in hand.
