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.

A luminous AI prototype crossing a guarded engineering bridge toward a stable production platform

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:

“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:

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:

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:

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:

  1. Reliability: request success, dependency errors and tool failures.
  2. Performance: end-to-end latency and time spent in retrieval, model calls and external tools.
  3. Economics: tokens, model calls and cost per completed business task.
  4. 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:

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:

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:

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.