A proof of concept that works in a demo is the easy part. Getting the same AI workflow into daily use, connected to your ERP, CRM or document store, with measured quality and someone responsible for it, is where most projects stall. For one well-scoped workflow, it takes about a week of preparation and six weeks of build. This playbook is for teams that already have a working experiment, such as a ChatGPT prototype or a vendor demo, and want it in production. It follows the same sequence as our AI Production Launch, but the steps apply whoever does the work.
First, two definitions. A proof of concept (PoC) shows that a model can do a task on a handful of examples. Production means named users rely on it every day, on live data, with quality you measure, access you control and costs you know.
Why do AI proofs of concept stall?
They rarely stall because the model isn’t good enough. The usual reasons are more ordinary:
- Nobody agreed what “good enough” means, so every review turns into a debate about one bad answer.
- The PoC ran on a hand-picked folder or a one-off export, not on live systems. Data access, cleaning and permissions were never arranged.
- Integration was left for “phase 2”. Reading from and writing to an ERP or CRM is usually more work than the prompt.
- Security, GDPR and the data processing agreement come up in week eight, when procurement first sees the project.
- Nobody knows what it will cost at real volume, so finance won’t approve a rollout.
- Nobody owns it after the demo.
Each of these is a planning problem. That’s good news, because you can fix them before you write production code.
What does “in production” mean for an AI workflow?
Use this table to see where your PoC stands. Anything in the right-hand column you can’t tick yet is work still to do.
| Typical proof of concept | In production | |
|---|---|---|
| Users | The team that built it | A defined user group, in daily work |
| Data | A sample or a one-off export | Live sources, synced, with known owners |
| Integration | Copy and paste | Reads from and writes to ERP, CRM or document systems through their APIs |
| Quality | ”Looks good” in a demo | Scored against an evaluation set and a baseline |
| Access | Everyone sees everything | Permissions mirror the source systems |
| Safety | Trust the prompt | Guardrails, human approval for actions, logging |
| Cost | Unknown | Cost per task measured, hard monthly limits |
| Operations | The developer’s laptop | Monitoring, alerts, a runbook and a named owner |
Start with one workflow and a hypothesis that can fail
Before you choose a model, write down what you will decide after a few weeks of real use. For example: “Customer service can answer delivery-date questions from the ERP without looking them up manually, and handling time per question halves.” If you can’t state a hypothesis that could turn out to be false, you are funding a demo.
Turn it into three to five metrics: accuracy on an evaluation set, time per task, how often a case is escalated to a person, cost per successful task and, for interactive tools, response time. Measure the baseline today, before any AI is involved. Without a baseline you can’t show an improvement.
Scope the workflow, not a feature list. “An e-mail arrives, the order lines are extracted and matched to articles, a draft order is created in the ERP, and a person approves it” is one workflow. Leave out extra languages, admin dashboards and the second use case until the first one runs.
What happens in the week before the build?
A short, paid audit week saves weeks of building the wrong thing. Ours runs for five business days:
- Day 1: a 2–3 hour workshop with the process owner and IT.
- Days 2–4: map the systems and data, check data quality and access, review the data flows for security and GDPR, and choose the model and hosting.
- Day 5: a written report with the recommended workflow, architecture, success metric and baseline, written acceptance criteria, risks and a fixed-price proposal.
One legitimate outcome is “don’t build it”. If the data isn’t there or the business case doesn’t hold, a week is a cheap way to find out. We go through the audit step by step in what a 5-day AI production audit covers.
Weeks 1–2: live data, an evaluation set and one thin slice
Set up access in your own cloud account and code repository from day one, so nothing has to be moved later. Build the data pipelines from the live sources, not from the export the PoC used.
The most important result of these two weeks is the evaluation set: a list of real inputs with the correct output for each, written or checked by someone who does the work today. Start with 50–200 cases and include the hard ones: ambiguous requests, missing data, questions that should be refused. Record document versions and dates so you never test on information that wouldn’t have existed at the time. If people edit the AI’s drafts later, keep those edits: they show you exactly where it falls short.
Then build one thin slice end to end on real data: input, lookup, model call, and output into the target system. Most first workflows use retrieval-augmented generation (RAG), which means the system looks up the relevant passages in your documents or data and gives them to the model together with the question. Fine-tuning is rarely needed for a first workflow; our comparison of RAG and fine-tuning explains when it is.
At the end of week 2, demo the slice against the acceptance criteria from the audit. In our launches this is the sprint-1 demo, and it comes with a guarantee: if it doesn’t meet the criteria we agreed in writing, you can stop and you don’t pay for that sprint.
Weeks 3–4: integration, human review and permissions
This is where most PoCs stop and the production work starts.
- Integration: connect the read and write paths to the systems the workflow touches, such as an ERP like Business Central, Fortnox or Visma, a CRM like HubSpot, or a document store like SharePoint. Writes need retries, protection against duplicates and error messages a user can act on.
- Human in the loop: start with draft and approve. The AI prepares the order, the answer or the classification, and a person confirms it. Remove the approval step later only for cases where the evaluation shows it’s safe.
- Permissions: users should only get answers from data they can already see in the source system. Filter what the system retrieves; don’t rely on instructions to the model.
- Logging: record inputs, retrieved sources, outputs and approvals, with personal data redacted and an agreed retention period.
- Prompt injection: if the workflow reads e-mails or documents from outside the company, assume someone will try to slip it instructions. Limit which actions it can take and require confirmation for anything that changes data.
Hold a demo at the mid-point with the process owner and a few future users. Their feedback now is much cheaper than after go-live.
Weeks 5–6: guardrails, monitoring, cost limits and go-live
The last two weeks turn a working system into one you can leave running.
- Guardrails: send low-confidence cases to a person, require sources for factual answers, and let the system say “I don’t know”.
- Monitoring: re-run the evaluation set on every change to prompts, models or data pipelines. Track error rate, escalation rate, cost per successful task and response time at the 95th percentile. For interactive tools, people tend to stop using them once that goes much above 5–8 seconds.
- Cost control: set per-user and monthly limits, cap the length of responses, use a smaller model for simple steps such as classification, and cache context that repeats. Have a switch that turns the AI step off and falls back to the manual process.
- Security review: walk through data flows, access and logging with your IT or security contact.
- Go-live: train the user group and switch the workflow on for them behind a feature flag, so you can widen access gradually. Start with a group small enough that you can talk to every user each week.
What should the handover include?
Use this as the acceptance checklist, and agree the values during the audit, not at the end.
- The workflow is running in production for the named user group.
- An evaluation report shows accuracy on the evaluation set against the baseline and the agreed threshold.
- Response time and cost per successful task are within the agreed limits, and a hard monthly cost cap is configured.
- Every write to the ERP, CRM or other systems is either approved by a person or limited to an allowlist of actions.
- Permissions have been tested with at least two different user roles.
- Logs redact personal data and have a defined retention period.
- Alerts fire on error rate, cost and model provider outages.
- A runbook explains how to switch the AI step off, roll back a change and swap the model.
- All code and infrastructure as code sit in your repository and cloud account.
- There is a named owner on your side and a decision on who maintains the workflow.
Which model and hosting should you choose?
Decide per workflow and don’t lock yourself to one vendor. Models from OpenAI, Anthropic and Google are available through EU-region or enterprise endpoints such as Azure OpenAI, AWS Bedrock and Google Vertex AI, and open models can run in your own environment when data must not leave it. Choose the cheapest option that passes your evaluation set and meets your data requirements. Make sure the endpoint doesn’t train on your data and that the provider is covered by your data processing agreement. Keep the model behind your own interface, so you can switch when prices or quality change. We go through token prices and running costs in the real cost of AI integration.
When should you stop instead of scaling?
Set the stop criteria before you start, so stopping isn’t a political decision later:
- The core metrics don’t move after two rounds of changes.
- The cost per successful task is higher than the value of the task.
- The data the workflow needs isn’t available, or can’t be cleaned within the timeline.
- The legal or safety risks can’t be limited with reasonable controls.
A clear “don’t invest further”, backed by evaluation results, is a good outcome. It costs you weeks, not a year.
Who needs to be involved on your side?
Fewer people than most teams expect: a process owner who knows the workflow, for 1–2 hours a week; someone in IT who can grant access to systems and data; and someone who can sign off on security and the data processing agreement. On our side, a senior engineer leads the build with a second engineer, both from our team in Ukraine, and a founder is accountable for delivery. The contract and the data processing agreement are with our Swedish company, and nobody on the team touches personal data until that agreement, with the EU Standard Contractual Clauses, is signed.
What to do next
If you have a PoC, or an idea for one workflow, write down the hypothesis and today’s baseline first. That alone will show whether it’s worth taking further. If you want help getting it into production, the AI Production Launch starts with a 5-day audit for €3,500, credited in full against the launch’s fixed price of €20,000–35,000 if you start within 60 days.