A workload-specific dependency check for data contracts, usable capacity, and recovery targets before an AI rollout goes to production.
The failure I keep seeing in production AI reviews is a gap between what the slide says and what the workload actually depends on. A team gets pilot approval, points at a cluster of accelerators, and declares itself ready to scale. Then the first real load exposes a data source nobody owns, a quota that was never a reservation, and a recovery plan that restores the application but not the model.
Readiness for a specific AI workload is not a general adoption checklist. It is a dependency review: can the data inputs, the compute and supporting services, and the recovery arrangements meet this workload’s production requirements? That is the question a CIO, CTO, or data leader has to answer before a rollout, and it is the question this piece walks through. This is the dependency map, not the failure-path testing plan. Detailed failover and recovery testing belongs in a separate reliability gate, and I flag where it hands off.
Coruzant Technologies publishes The Digital Executive, and most of our infrastructure coverage ends up circling the same lesson: scaling a model is a supply, data, and recovery problem long before it is a modeling problem.
Start with the workload, not the platform
The unit of review is one workload with its production requirements, not your AI platform in general. A platform can be “ready” in the abstract and still unable to run this workload at its target latency, freshness, and recovery tolerance.
So the first move is to write down what this workload actually needs: which data it consumes, what response time and throughput it must hit, how fresh its inputs have to be, and how much downtime or data loss the business will accept if it breaks. Those requirements drive every check below. Without them, “readiness” has nothing to measure against.
A data contract is more than a schema
A schema tells you the shape of the data. A data contract is the agreement between the producer and the consumer, and schema is only one part of it. Depending on the implementation, a contract can also cover semantics, quality rules, freshness or service expectations, ownership, security metadata, and the rules for how it is allowed to change.
Different tools express this differently. Confluent’s data contract documentation describes dimensions including structure, integrity constraints, metadata, and policies, plus compatibility controls and migration approaches for schema changes. DataHub organizes contracts around schema, freshness, and data-quality assertions. These are examples of what a contract can hold, not a single universal standard that guarantees every dimension is covered.
The distinction that matters for a readiness review is between what is machine-checked and what is only stated. OpenMetadata’s data contract specification, for instance, separates schema, semantics, and linked quality tests that a validation run can check from SLA, security, and terms-of-use sections that the same run does not check. A signed or cataloged contract is not proof that every obligation in it is enforced.

That gap is where AI workloads quietly break. The schema passes. The pipeline is green. But the meaning of a field drifted, or the data stopped arriving on time, and nothing in the validation run caught it because those terms were documentation, not tests. For a readiness review, write down two lists: contract terms that are automatically validated, and contract terms that are only documented. The second list is your exposure, and it is where poor data governance turns into a production incident.
Capacity means obtainable, usable capacity
A GPU count is not capacity. Usable end-to-end capacity for a workload includes the accelerator type and memory, the quota or reservation, the networking, the storage, the orchestration, and the ability to get those resources when the workload needs them.
Google’s AI infrastructure planning sequence runs in roughly that order: choose the workload and machine type, obtain capacity, select deployment and orchestration, then provision storage. Its documentation also separates clustered GPUs for large multi-host workloads from general GPUs for mainstream serving, retrieval-augmented generation, and smaller-scale training or fine-tuning. The right-sizing question is real: memory, throughput, and interconnect matter for large-model training and inference, while a mainstream serving workload can have very different needs. Those hardware specifics are provider- and product-specific, not general benchmarks.
The trap people fall into is treating quota as supply. These are different constraints. Google’s GKE guidance notes that GPU quota must cover intended use, and with autoscaling it should account for the maximum number of nodes multiplied by GPUs per node. Separately, on-demand capacity can hit stockouts, and clustered GPU capacity requires managed acquisition workflows. A quota approval is permission to use resources if they are available. It is not a confirmed reservation and not a guarantee of supply.
So in the review, for the compute dependency, record three separate states: is capacity requested, is it reserved or procured, and is it actually obtainable at rollout and at the growth level you expect? If you only have the first, you do not have capacity. You have paperwork.

You can forecast demand with workload telemetry. Google’s reliability guidance recommends using historical utilization and throughput to forecast accelerator demand, validating the estimate with load testing, and monitoring latency, throughput, errors, and accelerator utilization. Treat that as a planning method. A forecast and a load test reduce uncertainty; they do not promise that production will behave exactly as modeled.
Recovery targets are business-defined, not vendor defaults
RTO and RPO are the two numbers the business has to own before you pick a recovery design. AWS’s disaster recovery objectives define RTO as the maximum acceptable delay before service is restored and RPO as the maximum acceptable age of the recovery point, which is how you express tolerable data loss. Both describe recovery from a single disruption, which is different from availability over time or mean time to repair.

Recovery design is a tradeoff among cost, complexity, and those objectives. AWS describes recovery patterns ranging from backup-and-restore to pilot light, warm standby, and multi-site active-active, where lower recovery delay and less data loss generally require more continuously provisioned resources. The illustrative ranges are not a promise for your workload; the outcome depends on your architecture.

The most common mistake here is borrowing a product’s recovery figure and treating it as the workload’s guarantee. Oracle, for example, publishes configuration-dependent RTO and RPO figures for Autonomous AI Database backup-based recovery. Those apply to that documented offering and setup. They do not describe your AI application’s full recovery, which also depends on model artifacts, dependent data, identity, networking, and serving capacity. A database can meet its stated RPO while the application stays down because the model endpoint and its capacity were never part of the recovery plan.
Component targets can each look fine while full workload restoration is slower, or loses more data, than any single component suggests. The review needs a workload-level RTO and RPO approved by the business, and a recovery approach that plausibly meets them across every dependency, not just the database.
AWS and Azure both call for per-workload objectives tested through real failover and failback, and that testing belongs to the reliability gate, so this review stops at naming the dependency and target and confirming the approach fits them.
The dependency map
Run the review against each dependency below. The method for handling gaps is the same throughout: collect the listed evidence, then ask the readiness question, and record where the stated state and the real state diverge. The Status column is there for exactly that: mark each row Stated, Verified, or Gap.
| Dependency | Readiness question | Evidence to collect | Failure or gap to surface | Status |
|---|---|---|---|---|
| Source data and producer | Are sources identified, owned, and permitted for this workload? | Data inventory; producer and consumer owners; access and use constraints | A source exists but is inaccessible, stale, or not approved for the intended use | Stated / Verified / Gap |
| Data contract and change handling | Are schema, semantics, quality, freshness, and change rules explicit? Which are actually validated? | Versioned contract; compatibility policy; validation results; documented unvalidated obligations | Schema passes while meaning, freshness, or quality has changed | Stated / Verified / Gap |
| Data delivery and storage | Can ingestion, transformation, and storage meet volume, latency, retention, and recovery needs? | Throughput and freshness observations; storage and retention design; backup or replication evidence | The pipeline or storage becomes the bottleneck even when accelerators are available | Stated / Verified / Gap |
| Compute and capacity | Does the hardware fit the workload, and can the required capacity be obtained? | Workload sizing assumptions; quota; reservation or procurement status; scaling plan | Quota exists but capacity is unavailable, or accelerators are insufficient for the target workload | Stated / Verified / Gap |
| Network and orchestration | Can the workload schedule and communicate across required nodes and services? | Network and topology requirements; scheduler configuration; deployment dependencies | A multi-node workload cannot operate as assumed because of topology, scheduling, or network limits | Stated / Verified / Gap |
| Model and serving dependencies | Are model artifacts, runtime, endpoint, and supporting services available at rollout and recovery? | Artifact and version inventory; serving architecture; dependency owners and availability expectations | Recovery restores the application code but not the model, runtime, or serving capacity | Stated / Verified / Gap |
| Identity, security, and policy | Can authorized components access required data and services, including at recovery time? | Identity and access design; classification and policy records; recovery-environment permissions | The failover environment lacks permissions, secrets, or approved access paths | Stated / Verified / Gap |
| Recovery objectives and mechanisms | Are workload-level RTO and RPO agreed, and is the recovery approach consistent with them? | Business-approved targets; dependency-level recovery assumptions; backup or replication approach | Component targets look adequate but full workload restoration is slower or loses more data | Stated / Verified / Gap |
The row that most often gets skipped is model and serving dependencies at recovery time. Teams back up data and infrastructure config and assume the model comes along for free. It does not, unless the artifact, its runtime, and the serving capacity are explicitly in the recovery scope.
Who owns each answer
A dependency with no owner is an unresolved risk pretending to be done. For each piece of evidence, name an accountable owner and ask the review question before you sign off.
| Evidence or decision | Owner to identify | Review question |
|---|---|---|
| Producer-consumer contract, versions, and change rules | Data producer and consuming data or platform owner | Who approves a breaking change, and how are downstream consumers told? |
| Validation coverage and exceptions | Data quality or data platform owner | Which contract terms are automatically tested, and which are only documented? |
| Source permissions, classification, and permitted use | Data steward, security, and privacy or compliance owner | Are the intended data and recovery copies usable under the same controls? |
| Workload sizing assumptions and accelerator needs | ML platform or infrastructure owner, with the workload team | What workload profile supports the estimate, and what assumptions are unverified? |
| Quota, reservation, supply, and scale-out route | Cloud or infrastructure capacity owner | Is capacity requested, or actually available for rollout and expected growth? |
| Storage, network, orchestration, service dependencies | Platform owner for each dependency | Are dependencies available at the required scale and in the recovery location? |
| Business RTO and RPO and service priority | Business service owner, with the resilience or IT owner | What downtime and data loss are acceptable for this workload, not just one component? |
| Recovery approach, backups or replication, target validation | Resilience or DR owner, with application and data owners | Does the approach plausibly meet the approved targets, and where will testing be recorded? |
The last column in that table is where “ready” actually gets decided. If a review question has no clear owner, the honest status is not green.
Download both tables as a printable checklist (PDF)
FAQ
AI production readiness is the confirmed ability of one specific AI workload to run at its required latency, freshness, and recovery tolerance once real users depend on it. It is judged dependency by dependency: data sources and contracts, obtainable compute capacity, network and serving components, identity, and business-approved RTO and RPO. A platform can be capable in general and still not be ready for a given workload.
A schema describes the structure and types of data. A data contract is the broader producer-consumer agreement, which can also cover semantics, quality rules, freshness expectations, ownership, security metadata, and change rules. The schema is one enforceable part of it. Many of the other parts may be documented policy rather than checks a validation run enforces, which is why the review tracks what is machine-checked separately.
No. Quota is permission to consume resources if they are available. It is not a reservation and not a guarantee of supply. On-demand capacity can hit stockouts, and large clustered capacity often requires a managed acquisition workflow. In the review, track three states for compute: requested, reserved or procured, and actually obtainable at rollout and expected growth.
Those figures apply to the specific product and configuration they document, such as a database backup offering. Your AI workload’s recovery also depends on model artifacts, dependent data, identity, networking, and serving capacity. Set workload-level RTO and RPO with the business, then confirm the recovery approach plausibly meets them across every dependency, not just the component with the published number.
This review names each dependency, its recovery assumption, and the agreed target, and confirms the chosen approach is consistent with those. Actually testing failover and failback, and managing configuration drift in the recovery environment, belongs in a separate reliability gate. Keep them distinct so a review that says “target defined” is never mistaken for “recovery tested.”
What I would do first
Before touching capacity or recovery, pin down the workload’s production requirements and get the business to commit to an RTO and RPO. Almost every stuck review I have seen was stuck because those numbers were missing, so compute and recovery decisions had nothing to anchor to.
Then run the two tables as a working session with the named owners in the room. The point is not a tidy document. It is to surface the dependency that has no owner, the quota that was never a reservation, and the recovery plan that forgot the model. Those are the three that tend to decide whether the rollout holds.
For more context on the surrounding decisions, see our Enterprise Technology Trends coverage. If you want the executive-level thinking behind these reviews, The Digital Executive podcast from Coruzant Technologies runs interviews with the leaders making these calls.









