Applied AI ·
From AI Prototype to Production: A Practical Engineering Checklist
A practical checklist for taking an LLM or AI prototype into production, covering evaluation, security, observability, rollout and ownership.

An AI prototype proves that an idea can work under favorable conditions. A production system must continue working when the inputs are incomplete, the model changes, an integration slows down, a user enters something unexpected, or the business process does not match the demo.
That difference is where many promising AI projects stall.
The following checklist is designed for engineering leaders and software teams preparing to move an LLM application, retrieval-augmented generation system or AI agent beyond a controlled demonstration. It is deliberately practical. The goal is not to eliminate every risk before launch, but to make the remaining risks visible, owned and measurable.
Editorial note: Before publication, add one short first-hand example from Antonio's work here. Describe the system and constraint without disclosing confidential company or customer information.
1. Define the outcome before selecting the model
Start with the job the system must perform, not the model or framework you want to use.
Write down:
- who will use the system;
- what decision or task it supports;
- what a successful result looks like;
- what happens when it is wrong;
- how the process works without AI;
- which result can be measured after release.
“Build an AI assistant” is not an outcome. “Reduce the time required to find an approved support procedure while preserving access controls” is much closer. It identifies a user, a workflow, a useful result and an important constraint.
The baseline matters. If the current process is not measured, a polished demo can feel faster without producing a meaningful operational improvement.
2. Decide where deterministic software should remain in control
An LLM should not own every step simply because it can participate in every step.
Keep deterministic code around operations that require exact calculations, authorization checks, irreversible changes or strict business rules. Let the model classify, summarize, extract or propose when those tasks tolerate uncertainty. Put validation between a model response and any consequential action.
A useful design question is:
If the model returns a plausible but incorrect answer, what prevents that answer from becoming an incorrect action?
For an agent, document every available tool, the permissions attached to it, the arguments it accepts and whether a human must approve its execution. The smallest useful permission set is normally the safest starting point.
3. Build an evaluation set from real work
A few successful prompts are not a test suite. Before launch, collect a representative evaluation set that includes:
- common requests;
- ambiguous requests;
- incomplete or contradictory information;
- different languages and writing styles used by the audience;
- inputs the system must refuse;
- attempts to bypass instructions or retrieve restricted data;
- cases that previously caused failures.
Define what “good” means for each case. Some outputs can be checked exactly, while summaries and recommendations may require a rubric and human review. Record the model, prompt, retrieval configuration and evaluation result so a future change can be compared with the current release.
The important question is not whether the new version looks better in one conversation. It is whether it improves the agreed test set without introducing new critical failures.
Editorial note: Add the evaluation dimensions Antonio has actually used, such as factual correctness, completeness, citation quality, task completion, latency or cost.
4. Treat data access as an authorization problem
Retrieval does not remove the need for access control. If two employees are allowed to see different source documents, they must not receive the same retrieval results merely because they use the same assistant.
Verify:
- where prompts, files and responses are stored;
- whether a provider may retain or train on submitted data;
- how user identity reaches the retrieval and tool layers;
- whether permissions are enforced before content enters the model context;
- how secrets and personal data are removed from logs;
- how data can be deleted when required;
- which regions and subprocessors are involved.
Prompt instructions such as “do not reveal confidential information” are not an authorization boundary. Enforce access in the systems that retrieve data and execute actions.
5. Design for hostile and accidental input
Any text available to an LLM may contain instructions, including documents retrieved from an internal knowledge base or content copied from the web. Treat that content as untrusted input.
Test prompt injection, oversized requests, malformed tool arguments, unexpected file formats and attempts to make the model expose its context. Restrict tool permissions, validate arguments, isolate high-risk actions and require approval where the cost of a mistake is significant.
Security review should cover the entire system rather than only the model API: the user interface, identity provider, retrieval store, application backend, tool integrations, logging pipeline and administrative controls all contribute to the actual risk.
6. Specify failure and fallback behavior
The model will occasionally time out, return an invalid structure or produce an answer below the required confidence. External tools and retrieval systems will also fail.
For each dependency, decide:
- how long the application waits;
- which errors are retried;
- whether retries are safe and idempotent;
- what the user sees;
- whether a deterministic fallback exists;
- when the task is handed to a person;
- how partial actions are reconciled.
A clear admission that the system cannot complete a task is often safer and more useful than a confident approximation.
7. Make quality, latency and cost observable
Traditional service metrics remain necessary, but they are not sufficient for an AI system. Monitor at least four dimensions:
- Reliability: request success, dependency errors and tool failures.
- Performance: end-to-end latency and time spent in retrieval, model calls and external tools.
- Economics: tokens, model calls and cost per completed business task.
- Quality: evaluation regressions, user corrections, refusal accuracy, escalation rate and sampled human review.
Logs should make a failed interaction diagnosable without exposing sensitive content. Record version identifiers for prompts, models, retrieval indexes and tools. Otherwise, a team may know that quality changed without being able to reconstruct why.
8. Control versions and model changes
Model behavior can change when the provider, model version, system prompt, retrieval strategy or tool description changes. Treat these as deployable configuration.
Store them in version control where possible. Require review. Run the evaluation suite before promotion. Maintain a rollback path. Avoid silently routing all traffic to a new model because it performed well in a small manual test.
This discipline also makes cost optimization safer: a smaller model can be an excellent choice, but only when it meets the quality and latency requirements of the specific task.
9. Release gradually
A production launch should create evidence before it creates a large blast radius.
Start with a limited user group, a narrow workflow or read-only capabilities. Observe real interactions and compare them with the expected use cases. Expand only after the team understands the common failure modes and support burden.
Useful rollout controls include:
- feature flags;
- per-user or per-team enablement;
- rate and spending limits;
- shadow execution without user-visible actions;
- human approval for consequential tools;
- a kill switch that does not require a new deployment.
Communicate what the system can and cannot do. User expectations are part of the safety model.
10. Assign operational ownership
Before launch, name the people responsible for:
- application availability;
- model and prompt changes;
- evaluation quality;
- security incidents;
- source-data freshness;
- provider and token cost;
- user support;
- approving broader access or new tools.
Without explicit ownership, the prototype's creator often becomes the permanent and unofficial operator. That is fragile for both the person and the business.
Document the service, dependencies, dashboards, alerts, known limitations, rollback procedure and escalation path. Run a failure exercise before the audience becomes business-critical.
A compact release gate
An AI application is ready for a controlled production release when the team can answer yes to these questions:
- Is the business outcome and baseline clear?
- Are model responsibilities separated from deterministic controls?
- Does a representative evaluation suite pass?
- Are identity and data permissions enforced outside the prompt?
- Have prompt injection and tool misuse been tested?
- Are failures safe, visible and recoverable?
- Can the team observe reliability, latency, cost and quality?
- Are prompts, models and retrieval configuration versioned?
- Can the release be limited or disabled quickly?
- Does every operational responsibility have an owner?
The checklist does not make an AI system risk-free. It changes the conversation from “the demo worked” to “we understand how this service behaves, how it can fail and who is responsible when it does.” That is the point at which an AI prototype starts becoming an engineered product.
Editorial checklist before approval: Replace both editorial notes with truthful first-hand evidence, verify any company disclosure restrictions, add links to authoritative security/evaluation sources, and perform a final technical review.