AI development cost: full budget guide for 2026
Contents
Your board approved an AI initiative. Now someone needs to put a number on it — and the internet is full of billion-dollar training runs that have nothing to do with your roadmap. The gap between a GPT-4 headline and the actual invoice for a production-grade AI feature is enormous, and the difference lives in decisions your team will make in the next 90 days: which model layer to build on, how much proprietary data you're bringing in, and how you'll serve predictions at scale. If you want a partner to scope and build it, Netguru's AI development services team runs these engagements end to end.
TL;DR: AI development cost ranges at a glance
AI development projects fall into three budget tiers, and total cost of ownership (TCO) diverges sharply from the initial build cost once inference compute and MLOps overhead compound over time.
| Project tier | Typical scope | Build cost range | Year 1 TCO (incl. inference) |
|---|---|---|---|
| Proof of concept | Single model, synthetic data, no prod infra | $15K–$60K | $20K–$80K |
| Mid-market AI system | RAG pipeline, fine-tuned model, API integrations, monitoring | $80K–$350K | $150K–$600K |
| Enterprise AI platform | Custom model training, MLOps infra, human-in-the-loop review, multi-region | $400K–$1M+ | $800K–$2.5M+ |
Our team has delivered 60+ AI products for mid-market and enterprise clients; the recurring budget failure mode is underestimating inference at scale and Year 2–3 MLOps overhead. A mid-market project that builds cleanly for $180K routinely runs $300K–$400K by month 18 once GPU instance costs, model retraining cadence, and data preparation for retraining are factored in. The sections below explain each cost driver, phase by phase, so you can stress-test any vendor proposal before you sign it.
Why billion-dollar AI headlines don't apply to your budget
Frontier model training costs belong in a different conversation entirely. The figures that make headlines ($100M+ to train GPT-4-class models) describe one-time infrastructure runs on thousands of H100s by teams of hundreds of researchers. Those numbers are not a ceiling or a benchmark for applied AI projects; they are a distraction.
Here is what the cost landscape actually looks like for companies building on top of existing foundation models:
| Approach | Typical cost range | What you're paying for |
|---|---|---|
| Train a frontier model from scratch | $50M–$500M+ | GPU cluster time, petabytes of data, research team |
| Foundation model fine-tuning (7B–13B params) | $2K–$30K | A100/H100 compute hours, labeled dataset prep |
| LLM API usage (pure inference) | $0.50–$15 per 1M input tokens | Per-query billing, no infra ownership |
Fine-tuning costs far less than training from scratch because the base model's weights already encode language structure — your project only updates a fraction of parameters on domain-specific data. A 7B-parameter fine-tuning run typically completes in under 48 hours on A100/H100 instances. Pure API usage has a different risk profile: inference costs scale non-linearly once query volume grows. A system processing 500K requests per day sits at a materially different monthly run rate than a pilot at 5K requests, and that gap rarely appears in vendor proposals. The budget anchoring problem is not that companies over-invest — it's that they under-model the inference compute tail once the system reaches production load.
AI development cost by project tier: PoC, mid-market, enterprise
| Tier | Typical budget | Team size | Timeline | Typical stack |
|---|---|---|---|---|
| Proof of concept | $15,000–$50,000 | 2–3 engineers | 3–6 weeks | OpenAI/Anthropic API, LangChain, minimal cloud infra |
| Mid-market production | $80,000–$250,000 | 4–7 engineers | 3–6 months | Foundation model fine-tuning, RAG pipeline, SageMaker/Vertex AI, basic monitoring |
| Enterprise | $300,000–$1,200,000+ | 8–15+ engineers | 6–18 months | Custom/fine-tuned models, MLOps (Kubeflow, MLflow), human-in-the-loop review, dedicated inference compute |
8 cost drivers that actually move the budget needle
Data labeling and annotation, model retraining cadence, inference compute cost, and foundation model fine-tuning are the four drivers that together account for the largest share of AI development cost variance across projects. Rate them before you build the estimation table, not after. The other four are real but more predictable: human-in-the-loop review pipelines, MLOps infrastructure, retrieval-augmented generation architecture, and p95 latency requirements.
| Driver | Budget impact | Why it moves the needle |
|---|---|---|
| Data labeling & annotation | 🔴 High | Human annotation runs $0.05–$0.50 per label at scale; complex medical or legal labeling can exceed $5 per item. A mid-size NLP project may need 100K–500K labeled examples. |
| Inference compute cost | 🔴 High | Scales non-linearly with query volume. Per-token API pricing undercuts self-hosted at low volume; above ~50M tokens/month the economics invert toward dedicated instances. |
| Foundation model fine-tuning | 🔴 High | A single run on a 70B model still runs $2K–$15K. The real cost is iteration — three to six tuning cycles before production quality is typical. |
| Model retraining cadence | 🔴 High | The driver most vendor proposals omit. Monthly retraining on a mid-size model costs $3K–$8K per cycle in GPU hours plus engineering — $36K–$96K annually before MLOps overhead. |
| Human-in-the-loop review | 🟡 Medium | A customer-facing system typically needs 0.5–2 FTE reviewers. At $60–$120/hour, that adds $60K–$250K per year, rarely in the initial estimate. |
| MLOps infrastructure | 🟡 Medium | SageMaker/Vertex AI or a self-hosted stack adds $1K–$8K/month plus 20–30% engineering overhead. Under $200K total, managed MLOps is almost always cheaper than self-hosted. |
| RAG architecture | 🟡 Medium | Retrieval wiring, chunking strategy, and vector-store tuning add engineering time that scales with corpus size and freshness requirements. |
| p95 latency requirements | 🟡 Medium | Sub-100ms SLAs force dedicated instances or edge deployment, multiplying infrastructure cost versus best-effort batch inference. |
Cost by AI application type: chatbot, computer vision, agentic, and more
"How much does it cost to develop an AI app?" depends heavily on the application type — the model architecture, data requirements, and inference pattern differ enough that a single number is misleading. Here's how AI app development cost breaks down by the most common categories:
| Application type | Typical build cost | Primary cost driver |
|---|---|---|
| Conversational AI / chatbot (LLM + RAG) | $30,000–$120,000 | Prompt engineering, knowledge-base wiring, per-token inference at scale |
| Computer vision (detection, classification, OCR) | $60,000–$250,000 | Image annotation, GPU training compute, edge-deployment integration |
| Recommendation / personalization engine | $50,000–$180,000 | Behavioral-data pipelines, retraining cadence, feature-store infra |
| Agentic AI (multi-step, tool-calling) | $80,000–$200,000+ | Orchestration architecture, memory/state, tool integrations, eval harness |
| Predictive analytics / forecasting | $60,000–$200,000 | Clean historical data, drift monitoring, retraining pipelines |
The pattern: generative and agentic apps front-load less on data and more on ongoing inference, while vision and forecasting apps front-load heavily on annotation and training compute. A single-purpose LLM chatbot is the cheapest entry point; a computer-vision or agentic system carries the widest cost range because integration depth (edge hardware, tool-calling surface) varies most. Whatever the type, the AI app development cost figure in a vendor quote is the build number — the Year-1 total is typically 1.5–2× higher once inference and monitoring load in.
Generative AI vs. traditional ML: cost comparison
Generative AI and traditional ML follow opposite cost curves: traditional ML front-loads spend in data preparation and training compute, while generative AI shifts the burden to ongoing per-token inference fees. Neither is inherently cheaper — the right choice depends on whether your cost question is about capex tolerance or opex predictability.
| Cost dimension | Traditional ML (supervised/CV/regression) | Generative AI (LLM API + RAG + vector DB) |
|---|---|---|
| Build cost | $40K–$250K (data pipeline + training runs) | $15K–$80K (prompt engineering + RAG wiring) |
| Inference cost | Fixed infra (EC2/GKE), predictable per request | Usage-based; GPT-4o ~$2.50/1M input tokens, Gemini 1.5 Pro ~$1.25/1M |
| Maintenance burden | Model-drift detection + retraining every 3–6 months | Prompt regression testing + vector-index refresh |
| Data requirements | 10K–1M labeled examples by task complexity | Hundreds of docs for RAG; fine-tuning needs 1K–50K examples |
| MLOps platform cost | High — SageMaker/Vertex pipelines for retraining | Lower at launch; grows with retrieval infra as corpus scales |
Fine-tuning vs. training from scratch is the single largest cost delta in the traditional-ML column. Training a vision model from scratch on proprietary imagery can consume $20K–$150K in GPU compute alone; spot instances cut that 60–70% versus on-demand but add checkpoint overhead and interruption risk. Fine-tuning a pretrained model (ResNet, BERT) on the same dataset typically costs $2K–$15K.
For generative AI, LLM API pricing converts that capex entirely into opex. A mid-volume product at 500 requests/day, averaging ~2,000 tokens each, runs roughly $900–$2,500/month on frontier models before vector-database hosting ($150–$600/month at that scale). Prompt caching is the most underused cost lever on the generative side — caching prompt prefixes can cut monthly inference costs 30–50% when your system prompt is 2,000+ tokens sent with every request. This is core machine learning engineering work, whichever curve you land on.
In-house vs. agency vs. freelancer: engagement model cost comparison
Total cost of ownership shifts dramatically depending on which engagement model you choose, and the sticker price is rarely the honest number. In-house hires carry fully loaded costs that typically run 1.4–1.6× base salary once you factor in benefits, equity, recruiting fees, and the 3–6 month ramp before a new ML engineer is productive on your stack.
| Engagement model | Typical annual cost (US mid-market) | What's often missed |
|---|---|---|
| In-house ML engineer | $220K–$340K fully loaded | MLOps platform licenses, GPU credits, redundancy risk |
| Specialist agency (e.g., Netguru) | $180K–$420K/yr equivalent | Onboarding overhead; scope-change cost |
| Senior freelancer | $120K–$240K/yr equivalent | No MLOps continuity, drift risk, contractor compliance |
| Staff augmentation | $130K–$280K/yr equivalent | Management overhead stays with you |
Geographic rate differentials (hourly, senior AI/ML engineer)
| Region | Hourly rate range |
|---|---|
| North America | $150–$280/hr |
| Western Europe | $110–$190/hr |
| Eastern Europe (Poland, Romania, Ukraine) | $55–$110/hr |
| Latin America (Brazil, Colombia, Argentina) | $45–$90/hr |
| South/Southeast Asia (India, Vietnam) | $30–$75/hr |
Eastern European agencies, including Netguru (based in Poland), typically price senior AI work at $65–$100/hr, which puts a 6-month engagement at roughly $130K–$200K all-in for a 2–3 person team. That range covers architecture, model development, data preparation, and MLOps setup — but not your cloud infrastructure costs, which stay with you.
When each model wins on total cost of ownership
- In-house makes sense when you have ongoing AI work that justifies a team of 4+, your data-residency and GDPR requirements make external data access impractical, or your model requires continuous retraining pipelines a core team must own long-term.
- Agency wins when you need to move in under 90 days, your project needs breadth (data engineering + ML + MLOps + compliance) that one or two freelancers can't cover, or you're building toward an EU AI Act conformity assessment and want a team with documented process.
- Freelancers are cost-efficient for scoped, time-limited tasks: fine-tuning on a labeled dataset, a one-off data pipeline, or evaluating two vector-database configs. They break down post-deployment, where drift detection and retraining need continuity.
- Staff augmentation sits between agency and in-house — you get lower rates with your own management layer, but the coordination overhead shifts to your engineering leads. When you need embedded capacity fast, our AI team-as-a-service model covers exactly this.
Across 50+ engagements, our experience is that the agency model delivers the lowest total cost of ownership at the 12-month mark — not because day-rates are lower, but because scope definition, risk identification, and MLOps setup happen faster with a team that has done it before.
Industry-specific AI cost drivers: healthcare, fintech, retail, logistics
AI development cost varies more by industry than most budgets account for. Regulatory overhead, data-preparation complexity, and inference-architecture requirements each add a distinct cost layer on top of the baseline build.
Healthcare: compliance and clinical annotation premium
HIPAA Business Associate Agreements require de-identification pipelines before any patient data touches a model — typically adding $30,000–$80,000 in data-preparation cost before a single training run. Clinical annotation (radiology images, clinical notes, diagnostic codes) requires credentialed annotators, pushing labeling cost to $0.15–$0.40 per item versus $0.02–$0.05 for general-purpose text. Most diagnostic and triage systems qualify as high-risk under the EU AI Act, requiring a notified-body assessment before CE marking. Budget a 25–40% premium over a baseline NLP project.
Fintech: explainability infrastructure and fraud-label scarcity
Financial AI systems face a dual cost driver: regulators demand explainable models, and fraud-detection training data is structurally imbalanced. XAI tooling (SHAP, LIME, custom explanation layers) adds $20,000–$50,000 per model. Fraud-label scarcity means synthetic oversampling or manual labeling campaigns are near-universal, with labeling cost ranging $40,000–$120,000 for a production-grade fraud dataset. Expect a 20–35% premium over a comparable recommendation or search project.
Retail: catalog annotation at scale and retraining cadence
A product catalog of 500,000 SKUs requiring attribute extraction and image tagging can generate $75,000–$200,000 in upfront data preparation. The longer-term hidden cost is drift: demand-forecasting models degrade after seasonal inflection points, requiring quarterly or monthly retraining at $3,000–$12,000 per cycle in compute alone. Over a three-year horizon, retraining often exceeds the original development investment.
Logistics: real-time inference latency and edge deployment
Route optimization and warehouse automation frequently operate under sub-100ms latency SLAs that preclude standard cloud API calls, requiring dedicated GPU instances or edge deployment on hardware like NVIDIA Jetson modules. Edge deployment adds a one-time integration cost of $40,000–$90,000 for firmware, OTA update infrastructure, and hardware qualification. AI in logistics can cut forecasting errors materially — see AI in supply chain management — but when data-residency rules prohibit cross-border cloud processing, on-premises infrastructure costs rise a further 30–50%. Five-year TCO for an edge-deployed logistics model typically runs 2–3× the equivalent cloud-hosted project.
Phase-by-phase budget allocation (discovery through maintenance)
MLOps infrastructure and ongoing model retraining together consume more budget than most teams plan for — often 25–30% of total project cost, absorbed entirely in the post-launch phase.
| Phase | % of total budget | What drives the cost |
|---|---|---|
| Discovery & scoping | 5–10% | Architecture decisions, data audit, risk assessment |
| Data preparation & annotation | 20–25% | Labeling labor, storage, pipeline setup |
| Model training / fine-tuning | 15% | GPU instance time (A100/H100), fine-tuning API calls |
| Testing & evaluation | 10% | Hallucination benchmarking, p95 latency testing, HITL review |
| Deployment & integration | 15% | Inference compute, API gateway, CI/CD wiring |
| Maintenance & monitoring | 25–30% | MLOps infra, retraining cadence, drift monitoring, relabeling |
Data preparation is the phase most often underestimated. For a mid-market computer-vision project we delivered for a logistics customer, labeling consumed 22% of the total budget — roughly $55,000 of a $250,000 engagement — before a single training run started. Teams that budget 5–10% for data prep routinely hit scope overruns by month two.
Discovery costs appear small (5–10%), but decisions made there set the inference architecture, which fixes the shape of ongoing inference compute cost. Underinvesting in discovery by $10,000–$20,000 commonly shifts $80,000–$150,000 of rework into deployment. Treat discovery as a cost-avoidance mechanism, not an administrative formality.
Infrastructure cost breakdown: cloud compute, GPUs, vector DBs, LLM APIs
GPU instance pricing and LLM API token costs are the two largest infrastructure line items in most AI projects, and both scale in ways that catch engineering budgets off guard.
Cloud GPU instances. On AWS, an ml.p4d.24xlarge (8× A100 80GB) runs roughly $32–$38/hour on-demand; a single p3.2xlarge (1× V100) sits closer to $3.06/hour. GCP's A100-backed a2-highgpu-1g lists around $3.67/hour, while an H100-based a3-highgpu-8g reaches $33–$40/hour depending on region. Spot and preemptible instances cut those figures up to 90% — useful for batch fine-tuning but not for latency-sensitive inference, where preemption would break p95 guarantees. On a slower GPU (T4, ~$0.53/hour) throughput is ~one-fifth of an A100, so the per-hour saving evaporates on wall-clock time.
LLM API costs. As of mid-2026, GPT-4o input tokens run ~$2.50 per 1M and output ~$10.00 per 1M; Claude 3.5 Sonnet is comparable. A customer-facing assistant handling 500,000 queries/month (≈400M input + 150M output tokens) translates to roughly $1,000–$1,500/month in API costs alone, before vector-database retrieval overhead. Projects that model this as a rounding error routinely face a 3–5× overage at production volume.
Vector databases. Modest at low scale but additive in large-corpus RAG systems: a 10M-vector index with 1M queries/month runs $99–$199/month on Pinecone serverless. Self-hosted alternatives (Weaviate, Qdrant on a cloud VM) shift cost to compute and storage — typically $200–$800/month for a mid-size corpus — but add operational overhead.
Hidden AI costs most budgets miss
Model-drift detection and retraining pipelines, MLOps platform licensing, data annotation for retraining batches, human-in-the-loop labor, and change management are the five cost drivers that rarely appear in vendor proposals — yet together they add 40–80% to first-year total cost of ownership in most production AI systems.
Model drift and retraining pipelines
Model drift is not hypothetical. Across NLP and classification projects we've delivered, models show measurable accuracy degradation within three to nine months as input distribution shifts. Two strategies carry different cost profiles:
- Scheduled retraining (quarterly/monthly): adds ~15–25% of original development cost per year for data prep, fine-tuning compute, and validation. Predictable, but may lag fast drift.
- Triggered retraining (drift-threshold): requires a monitoring stack (Evidently AI, WhyLabs, Arize). Managed drift-detection licensing runs $2,000–$8,000/month by prediction volume; self-hosted lowers the fee but adds 0.5–1 FTE in MLOps time.
Labeling 10,000 examples for a retraining cycle costs $3,000–$15,000 via crowdsourced platforms or $8,000–$30,000 with domain-expert annotation for regulated outputs.
Human-in-the-loop review: a staffing cost, not an infrastructure cost
For regulated outputs — loan decisions, medical coding, content moderation — HITL review shows up on payroll, not in your infrastructure breakdown. Based on our benchmarks, HITL typically requires 0.5–2 FTEs per 100,000 monthly reviewed decisions, and it scales directly with adoption: double your user base, double the review labor. On one AI-assisted claims-processing engagement, automation plus a lean HITL layer reduced manual processing time by 83%, but the residual review labor still had to be staffed in the year-one budget.
EU AI Act conformity assessment
High-risk AI systems face mandatory conformity assessment before deployment — a fixed overhead with no equivalent in pre-2024 software budgets. Third-party assessment fees for a high-risk system run €15,000–€60,000 for initial certification, with annual surveillance audits adding €5,000–€20,000.
Change management and internal adoption
Change management almost never appears in AI cost estimation, yet it's consistently one of the largest hidden drivers where internal teams must adopt new workflows. Documentation, shadow-mode deployment, and staff training account for 8–15% of total project cost in enterprise rollouts. A generative AI assistant replacing a manual research workflow — like the Merck R&D assistant that compressed a 6-hour search to minutes — still required internal training and a shadow-mode period before full adoption. For how these hidden costs compare across technology projects, broader software development budgeting frameworks typically exclude operational and change-management line items entirely.
The five most commonly missed AI budget line items:
| Line item | Typical annual cost | Why it's missed |
|---|---|---|
| Model-drift detection + retraining | $24,000–$120,000/yr | Not visible until post-launch accuracy degrades |
| Data annotation for retraining batches | $10,000–$60,000/yr | Treated as one-time cost at project start |
| MLOps platform licensing (managed) | $24,000–$96,000/yr | Absorbed into vague "cloud costs" |
| Human-in-the-loop review labor | 0.5–2 FTEs per 100K decisions/mo | Lands on payroll, not project budget |
| EU AI Act conformity assessment (high-risk) | €20,000–€80,000 yr 1 | Unrecognized at scoping stage |
These costs don't invalidate AI investment — the Merck and ARC Europe outcomes show the ROI case holds. They do mean total cost of ownership needs a post-launch line item from the first scoping conversation, not after the first production incident.
Regulatory and compliance costs: GDPR, HIPAA, and the EU AI Act
Compliance is a cost driver most budgets ignore until legal review flags it — at which point the expense is locked in by architecture decisions already made. For projects touching personal data, protected health information, or high-risk AI classifications, regulatory cost estimation should happen during discovery.
GDPR compliance in an AI pipeline is harder than in a conventional app. Data-residency infrastructure (EU-only regions) adds 10–20% to infrastructure cost; a DPIA runs €8,000–€25,000 in external legal/DPO fees; and right-to-erasure in ML pipelines can't be satisfied without retraining or machine-unlearning techniques, usually addressed at data-prep with pseudonymization (adds two to four weeks of development).
HIPAA requires a Business Associate Agreement with every cloud provider and third-party vendor — and not every service qualifies, which can force architecture compromises. Annual HIPAA audits for AI systems typically run $15,000–$40,000 one-time plus $10,000–$30,000 recurring, and inference-layer audit logging of every PHI query adds storage and egress that compound with volume.
EU AI Act conformity assessment is the highest single compliance cost item for high-risk projects (employment screening, credit scoring, critical infrastructure, medical devices — full list in Annex III of the Act). A conformity assessment including technical documentation, third-party audit, and CE-marking overhead runs approximately $20,000–$80,000, and high-risk classification triggers ongoing post-market monitoring that adds 15–25% to total project cost over three years. Foundation-model API dependencies may pull GPAI obligations upstream even when your own system falls below the compute threshold — useful context on where models sit relative to AGI/ASI concepts.
| Framework | Typical one-time cost | Recurring annual cost | Primary cost drivers |
|---|---|---|---|
| GDPR | €8,000–€25,000 | €3,000–€10,000 | DPIA, legal review, right-to-erasure engineering, data-residency premium |
| HIPAA | $15,000–$40,000 | $10,000–$30,000 | BAA setup, compliant architecture, audit logging, annual audit |
| EU AI Act (high-risk) | $20,000–$80,000 | $8,000–$25,000 | Conformity assessment, technical docs, post-market monitoring |
Projects subject to more than one framework — a medical AI system deployed in the EU, for example — should stack these estimates rather than average them.
3-year total cost of ownership: build year vs. operate years
Total cost of ownership shifts dramatically between Year 1 and Years 2–3. Build-year costs are front-loaded, one-time capital expenditure; operate years are dominated by recurring MLOps infrastructure, inference compute, and retraining — and those recurring costs typically exceed the original development cost by year 3. Before a multi-year build, the build-vs-buy decision deserves scrutiny; off-the-shelf solutions may carry lower TCO despite higher licensing fees.
Representative TCO for a mid-complexity AI system (document processing or semantic search, ~$200K–$400K to build):
| Cost category | Year 1 (build) | Year 2 (operate) | Year 3 (operate) |
|---|---|---|---|
| Development (engineering, fine-tuning, integration) | $250,000–$380,000 | $30,000–$60,000 | $20,000–$40,000 |
| Inference compute (GPU / API tokens) | $8,000–$20,000 | $40,000–$120,000 | $60,000–$180,000 |
| MLOps infrastructure (monitoring, pipelines, storage) | $12,000–$25,000 | $30,000–$55,000 | $35,000–$65,000 |
| Model retraining cadence | $0–$15,000 | $20,000–$50,000 | $25,000–$60,000 |
| Human-in-the-loop review | $10,000–$20,000 | $25,000–$50,000 | $30,000–$60,000 |
| Estimated total | $280,000–$460,000 | $145,000–$335,000 | $170,000–$405,000 |
The pattern across projects: inference costs in Year 2 run 3–6× higher than Year 1, because the Year 1 figure covers only the tail end of a partially loaded system. By Year 3, cumulative OPEX has matched or exceeded the original build investment for most systems with meaningful query volume. Merck KGaA's document-processing project is a useful calibration — the build cost was justified in Year 1, but the reason it stayed funded was Year 2–3 operating cost running well below the labor it displaced.
Frequently asked questions about AI development costs
How much does custom AI development cost?
How much does it cost to develop an AI app?
How much does AI agent development cost?
What factors influence the cost of AI development most?
How much does AI development cost for a startup?
What does generative AI cost compared to traditional ML?
What regulatory compliance costs should I budget for an AI project?
How do AWS, GCP, and Azure AI infrastructure costs compare?
Ready to scope your AI budget? Start with a fixed-price discovery
A proof-of-concept sprint is the lowest-risk way to pin down your total cost of ownership before committing to full development. For $15,000–$30,000 and three to four weeks, you get a validated data model, an inference-architecture decision, and a cost-per-query estimate that makes the rest of the budget predictable.
We've run discovery sprints for companies from scale-ups to listed enterprises, and the pattern is consistent: the projects that stay on budget are the ones that invested in scoping first. If you're mapping AI development costs for a 2026 investment, Netguru's AI development services team can run a fixed-price discovery covering model selection, data-preparation requirements, and an MLOps infrastructure estimate — so you go into build with a number you can defend, not a range.
