From Idea to AI Feature in Six Weeks

Many AI projects stall between a promising demo and a feature people rely on. The demo answers a few hand-picked questions; the real feature must handle messy inputs, run reliably, stay within budget and keep getting better. Six weeks is a realistic time frame for taking one well chosen use case from idea to production, if the work is planned in that order. Here is how we structure it.

Week 1: discovery

The aim is to choose the right problem and define success.

• Map the current process and find the step where AI removes the most manual work at acceptable risk.
• Collect real examples: documents, tickets, emails or questions the feature will face, with the outcomes a person would produce.
• Agree on measurable success criteria, for example accuracy on the example set, time saved per item, response time and a cost ceiling per request.
• Check constraints early: personal data, GDPR obligations, data residency, and whether hosted APIs are acceptable.

The output is a short written scope and a first evaluation set. If the examples show the task is not feasible, this is the cheapest moment to find out.

Week 2: design

Decide how the feature works before building it.

• Choose the approach: prompting, retrieval (RAG), tool use, or a combination. Fine-tuning rarely belongs in a first release.
• Shortlist models, hosted and open, and decide what to try first.
• Design the human review step, the guardrails and the audit trail.
• Sketch the architecture: where the feature runs, how it reaches data, how requests are authenticated and logged.

Week 3: prototype and evaluate

Build the smallest working version and measure it against the evaluation set. Compare two or three models and prompt variations. Expect the first scores to disappoint; most of the progress comes from reading failures and fixing their causes, such as poor document parsing, missing context or ambiguous instructions.

By the end of the week you should know which approach and which model to take forward, with numbers to back the choice.

Week 4: infrastructure

Turn the prototype into a service your team can operate:

• Deploy through the same pipelines as your other services, with infrastructure as code in Terraform or a similar tool.
• Put model calls behind a gateway with authentication, rate limits, retries and cost tracking.
• If self-hosting, set up the inference server (vLLM or similar), GPU capacity and autoscaling.
• Add metrics, traces and logging: tokens, latency, cost per request, errors and quality signals.
• Wire the evaluation set into CI so prompt and model changes are tested before release.

Week 5: rollout

Release to a small group first, often internal users or a single team. Keep human review on for every item at this stage. Collect feedback and corrections, watch the dashboards, and fix what you find. Widen access when the quality and operational numbers hold steady.

Week 6: measure and improve

Compare results against the success criteria from week 1. Typical questions:

Question	Where the answer comes from
Is it accurate enough?	Evaluation scores and reviewer correction rate
Is it saving time?	Handling time before and after
Is it affordable?	Cost per request and monthly projection
Is it reliable?	Error rate, latency, incidents

Agree on the next round of improvements and on which review controls can be relaxed. Hand over runbooks and dashboards so your team can operate it without us.

What makes six weeks possible

The time frame works because the scope is narrow: one use case, one workflow, measured against clear criteria. It also depends on access to real data and a person from the business who can judge outputs and make decisions quickly. Without those, any timeline slips.

After launch

An AI feature is never quite finished. Inputs drift, models are updated and retired, and users find new edge cases. Keep the evaluation set growing, review a sample of outputs regularly, and treat prompt and model changes with the same care as code changes.

DoneDeploy runs AI projects this way as fixed-scope packages, from discovery through infrastructure to the measurement that guides what comes next. If you have a use case in mind, let’s talk.