The Differences That Matter
Lesson 3 of 3 in Bedrock, Azure AI Foundry, Vertex AI.
After the tour, the checkboxes all match — which means checkboxes can no longer make the decision. In practice, four deltas do.
Catalog composition. Not the counts — the exclusives and the escape hatches. Each catalog carries model families the others do not, and some families now appear in all three (the docs pages behind our matrix list Anthropic models in Bedrock’s catalog, in Foundry’s partner category, and in Model Garden’s partner models). The escape hatches differ more than the headliners: Bedrock’s Custom Model Import brings your own Open weights weights behind the on-demand API, while Model Garden’s self-deploy path runs open models on compute in your own project and VPC — with your own containers.
Cross-region and global serving. All three route globally; they hang the switch in different places. On Bedrock it is an inference profile you invoke; on Azure it is the deployment type itself; on Vertex it is the endpoint hostname. The sweeteners and constraints differ too: Bedrock documents its global profiles at approximately 10% savings; Azure documents a Global-first rollout order for new models; Vertex documents the global endpoint’s feature exclusions. Where the switch lives determines who in your org controls it — the caller, the deployer, or the client configuration.
Customization depth. The SFT baseline is universal. Past it, the menus fork: Bedrock adds reinforcement fine-tuning with Lambda-scored rewards, managed distillation, and weight import; Foundry adds DPO and RFT on documented model sets, with serverless the exclusive route for OpenAI models; Vertex adds preference and RL tuning on an adapter model with multimodal training data, checkpoints, and continuous tuning. If your roadmap includes anything beyond supervised fine-tuning, this row alone can decide the platform.
Guardrail configurability. Same slot, three architectures: a standalone versioned resource callable outside any model invocation (Bedrock, including Automated Reasoning checks and contextual grounding checks); filter configurations attached to individual deployments, with approval gates on weakening them (Azure); per-category thresholds over a non-configurable base layer, plus a citation filter (Vertex). Which architecture fits depends on whether your safety controls live with the platform team, the app team, or the request path.
| Delta | Amazon Bedrock | Azure AI Foundry | Vertex AI |
|---|---|---|---|
Catalog composition | 100+ serverless FMs (per the User Guide overview) + 100+ Marketplace models to SageMaker AI endpoints; Custom Model Import for your own weights | 10,000+ models (per the docs), split sold-by-Azure (incl. Azure OpenAI) vs. partners/community (incl. Hugging Face hub) | Google-only families (Gemini, Veo, Lyria) + partner + open models; self-deploy in your own VPC, custom containers allowed; no stated total |
Cross-region / global switch | Inference profile at invocation: geographic (US/EU/APAC) or global at ~10% documented savings; profiles don’t support Provisioned Throughput | Deployment type: Global → Data Zone → regional, with data at rest always in the designated geography; new models roll out Global-first | Endpoint choice: regional, us/eu multi-region, or global — global excludes tuning, some batch, RAG corpora; PT only for enumerated Gemini models |
Customization depth | SFT + reinforcement fine-tuning (Lambda reward functions) + managed distillation + weight import; customized models require Provisioned Throughput | SFT (broadest set) + DPO (GPT-4o/4.1) + RFT (o4-mini); serverless is the exclusive route for OpenAI models | Adapter-based SFT + preference + RL tuning with your own reward functions; text/image/audio/video/document data; shares base-model quota |
Guardrail configurability | Standalone, versioned guardrails; ApplyGuardrail API works without a model call; Automated Reasoning checks; contextual grounding checks | Filter configs attached per deployment; Prompt Shields; disabling or annotate-only mode requires approval | Per-category probability/severity thresholds; non-configurable CSAM/SPII layer; citation filter for recitation |
Interactive sorting exercise: A vendor slide makes each of these claims about their cloud’s model platform. Sort each one: is it table stakes that all three platforms document, or a genuine differentiator that only one of the three documents?
Tool: Cloud Model Selection Matrix — Every claim in this module, cell by cell, with a per-cell source link and the verification date: open the Cloud Model Matrix and compare the three platforms facet by facet — then pressure-test a vendor slide against it.
In production
Platform choice is rarely a green-field bake-off. It usually follows the cloud where your data, identity, and operations already live — and that is a defensible default, because integration surface compounds. The deltas in this lesson are what justify exceptions.
AWS
On an AWS estate, Bedrock is the default answer. The deltas that pull outside workloads in are customization breadth — reinforcement fine-tuning, managed distillation, Custom Model Import — and standalone guardrails via ApplyGuardrail, which safety teams can run over any text pipeline. Work the constraint chain on paper before committing: customized models require Provisioned Throughput, and inference profiles do not currently support it, so a workload that wants residency routing and a fine-tuned model and committed capacity needs its serving path designed up front.
Azure
On an Azure estate, Foundry is the default, and the sold-by-Azure category — Azure OpenAI models with Microsoft hosting and support — is the delta that historically pulled non-Azure shops in. Treat the deployment-type ladder as an architecture input: Global-first rollout means the newest models may lag in your required geography, and quota is assigned per region, per model, per deployment type, so capacity planning is a design task, not an afterthought. Plan the managed-RAG path around the documented On Your Data retirement; its recommended successor lives on the agent platform — our sister academy’s territory.
Google Cloud
On Google Cloud, Vertex is the default; the deltas that pull others in are the Google-only model families (Gemini, Veo, Lyria) and the self-deploy path — open models on compute in your own project and VPC, with custom containers, the closest a managed catalog gets to self-hosting without owning the cluster. Check endpoint-choice consequences early: the global endpoint excludes tuning and RAG corpora, and tuned-model inference shares the base model’s quota — customizing a model does not add capacity for it.
Interactive checkpoint quiz (1 questions) — open this page in a browser to take it.