Build, Buy or Compose Is Really a Question of Control and Portability
Enterprise AI build buy compose strategy is really a set of ownership decisions across models, workflows, tools, data, evaluation and operations. See how control and portability determine what to build, what to buy and which capabilities to compose.

Introduction
Three proposals arrive for the same enterprise AI assistant.
One is a packaged application that can be deployed quickly. The vendor owns most of the AI stack, updates it continuously and exposes a defined set of configuration and integration points.
The second is a custom application. The enterprise chooses the models, owns the workflow logic, controls the user experience and integrates directly with its systems.
The third sits between them. The company buys access to managed models, uses managed infrastructure for selected capabilities, keeps its own business logic and data contracts, and combines those pieces into an application it operates.
All three may satisfy the same use case, but they create very different ownership structures. The difference is not simply whether the enterprise builds or buys. It is which parts of the system the enterprise controls, which parts another provider can change, and how difficult those decisions will be to reverse later.
That is why an enterprise AI build buy compose strategy is ultimately a question of control and portability.
At a glance
- Build, buy and compose describe different distributions of ownership rather than three fixed architecture categories.
- Control should be examined separately across models, data, workflow logic, tools, identity, evaluation and user experience.
- Buying transfers operating responsibility but can also transfer authority over release cadence, product behavior and available integration points.
- Composed architectures let enterprises own selected layers while using managed capabilities for others.
- Portability is best understood as the effort required to change an ownership decision later without rebuilding the entire application.
Build versus buy is no longer one decision
Traditional enterprise software made the build-versus-buy question relatively easy to recognize: purchase a finished product or create software the organization largely controls. AI systems divide that choice into smaller decisions because the model, workflow, retrieval, tools, evaluation and user experience can all sit on different sides of the ownership boundary.
An enterprise may buy a general-purpose model, build the user experience, use a managed retrieval service, connect proprietary business APIs and operate its own evaluation suite. Another company may buy almost the entire application and configure only its data sources and access rules.
Microsoft’s current AI strategy guidance for SaaS businesses reflects this mixed model. It advises organizations to use established general-purpose models rather than build them from scratch, while building agent experiences and workflow integrations when those layers express differentiated business value. It also notes that many products benefit from combining several implementation approaches.
The more useful architecture question is therefore not whether the complete application is “built” or “bought,” but where the enterprise chooses to own the behavior.
Control has to be examined layer by layer
Consider a customer-service assistant. The enterprise may care about controlling which customer information enters the context, which models can process the request, how business rules are applied, which tools the assistant can invoke, what identity reaches downstream systems, how responses are evaluated, when changes go live and what users see.
A packaged application may expose some of those decisions through configuration while keeping others inside the vendor’s product boundary. A custom application may expose more of them directly to the enterprise engineering team.
Neither arrangement is automatically superior. The relevant question is whether the controls that matter to the business sit on the enterprise side of the boundary, particularly when the AI system participates in proprietary processes.
A company may be comfortable allowing a provider to operate the foundation model while insisting that customer eligibility rules, approval logic or transaction authority remain under its own control.
Buying transfers responsibility and authority together
Buying AI software can remove a substantial amount of operating work. The provider may own model integration, scaling, security updates, monitoring, support and much of the release process, which can make economic sense for a common business problem.
Some change authority moves with that responsibility. A vendor may decide when models change, which features are retired, how the product behaves after an update, which capabilities become available and where integration boundaries remain fixed.
AWS provides a useful example in its discussion of Claude Enterprise in AWS Marketplace. AWS describes Claude Enterprise as the buy option: a finished collaboration product requiring no application development. The same underlying Claude model family can instead be accessed through Amazon Bedrock and incorporated into a custom application.
The model may be similar across both choices, but the ownership structure is different. The packaged product transfers more implementation work to the provider; the custom application leaves the enterprise responsible for more of the behavior around the model.
Source-code ownership does not automatically equal architectural independence
“Build” can be misleading for the opposite reason. An enterprise may write most of an application while remaining dependent on managed models, vendor-specific tool formats, proprietary retrieval services or another provider’s runtime conventions.
Source-code ownership does not automatically equal architectural independence.
A custom application may still be expensive to change if prompts assume one model family, tools depend on one calling format, evaluations rely on one trace structure or application logic is tightly coupled to a provider-specific service.
The useful measure of control is not how much code the organization wrote, but how much of the system can change without forcing large changes elsewhere. That shifts the discussion from source ownership to dependency ownership.
Compose makes ownership a component-by-component decision
Composition is increasingly attractive because the enterprise does not need the same ownership posture for every layer.
AWS’s Generative AI Application Builder, for example, combines managed foundation models with retrieval, guardrails, agents, external model connectors and application components. Google’s enterprise generative AI and ML blueprint similarly shows a layered architecture spanning enterprise foundations, identity, networking, data, model development, serving and deployment pipelines.
That structure lets an enterprise buy capabilities that do not differentiate the business while keeping ownership of the parts that do. A bank may buy model access but own credit-policy logic. A manufacturer may use a managed agent runtime while keeping production-system interfaces behind enterprise-controlled APIs. A legal application may buy document extraction while owning the reasoning workflow that compares clauses and determines what requires review.
Composition therefore turns a single build-or-buy choice into several ownership decisions made at different layers of the application.
Business-specific behavior usually deserves the closest scrutiny
Not every layer requires the same degree of enterprise control. General-purpose model inference is increasingly available from multiple providers, and recreating that capability from scratch would make little sense for many enterprise applications.
Business-specific behavior deserves closer scrutiny because application value may depend on how internal policy is interpreted, how authority is checked, how a workflow proceeds or how proprietary data influences a decision. Losing control over that behavior can make future change much harder.
Microsoft’s SaaS guidance makes a similar distinction by placing established general-purpose models on the buy side while treating differentiated agent experiences and workflow integration as areas where building can make sense.
A useful deployment principle follows: buy commodity capability more readily than business-specific behavior.That does not mean every differentiated workflow must be custom-built; it means the enterprise should understand which behaviors it must remain able to alter independently.
Portability is the cost of reversing an ownership decision
The value of control becomes clearest when the enterprise later wants to change something. Models improve, prices change, product capabilities disappear, a new jurisdiction imposes different requirements or a provider stops supporting an integration the business now considers important.
Portability determines how much work follows from that change.
At the model interface, Amazon Bedrock’s Converse API provides a consistent request structure across supported models. AWS describes this as a way to write application code once and use it with different models.
That removes one category of switching work without making the models behaviorally identical. Prompts can perform differently, tool use can vary, context limits differ and the replacement still needs to satisfy the application’s evaluations.
Two forms of portability therefore matter:
interface portability asks whether another component can connect without substantial integration work.
behavioral portability asks whether the replacement can meet the same operating expectations without forcing the application around it to change.
A common interface can improve the first. The second still has to be demonstrated.
Open interfaces can preserve application optionality
Open interfaces can reduce the amount of application logic tied to one runtime.
Anthropic describes MCP as an open standard for connecting AI systems with external tools and data sources, and it argues that open protocols can keep competition focused on agent quality and safety rather than ownership of integrations. MCP was later donated to the Linux Foundation’s Agentic AI Foundation.
For an enterprise application, the practical value is boundary reuse. An internal capability exposed only through one proprietary agent framework may have to be rebuilt when that runtime changes. A capability exposed through a durable enterprise API or broadly supported interface has a better chance of surviving replacement of the model or agent layer above it.
The protocol does not eliminate migration work; it can reduce how much of the application has to move with one component.
Portability should focus on the parts of the application the enterprise may need to recover
Data export is often the first portability question, but it is rarely the only one.
A packaged AI application may allow clean export of enterprise data while keeping prompts, workflow definitions or evaluation history inside the product. A custom application may preserve those artifacts but still depend on interfaces that are difficult to reproduce elsewhere.
For deployment decisions, several forms of portability are worth separating:
- data portability — can the enterprise recover the information it supplied or generated?
- configuration portability — can prompts, policies and workflow settings be retained?
- integration portability — can the same enterprise tools and APIs be reused?
- evaluation portability — can the same acceptance cases and expected outcomes be applied to a replacement?
These categories stay close to the application being deployed. They help explain what an ownership decision may cost to reverse without turning the discussion into a broader theory of platform control planes or infrastructure lock-in.
Choice inside a provider is useful, but it is not the same as exit portability
AI services increasingly offer more than one model or deployment mode within the same provider.
Google supports both serverless Model as a Service and self-deployed open or partner models for supported offerings.
Amazon Bedrock exposes several runtime APIs, including Converse and OpenAI-compatible interfaces for supported workloads.
That flexibility can make it easier for an application team to change a model or serving approach without rewriting the entire application, but it should not be confused with complete cross-provider portability.
The practical deployment point is narrower: a composed application can offer more substitution options than a monolithic product when the enterprise has preserved usable boundaries around the components it may later want to change.
Switching cost should be considered before the dependency becomes normal
Portability is easier to preserve before production workflows, user behavior and operating assumptions form around a component.
Replacement questions are therefore useful during the original build, buy or compose decision. If the model changes, what must be revalidated? If a packaged product is replaced, which workflow definitions can be recovered? If an enterprise tool moves to another AI runtime, can the same API still be called? If an evaluation service disappears, does the organization retain its own test cases and expected outcomes?
These questions do not imply that managed services should be avoided. They reveal the trade the enterprise is making when it accepts someone else’s component as part of a production application.
Build can create internal lock-in too
Vendor dependence is not the only way portability can disappear.
A custom AI application can become difficult to move because prompts are undocumented, business rules are buried in application code, data access is tightly coupled, evaluations live in one engineer’s scripts or interfaces are understood by only one internal team.
The enterprise owns every line of code and can still become trapped by its own design.
Portability therefore has to be created deliberately through understandable boundaries, documented contracts, retained test evidence and components that can be changed without reconstructing the entire system. Owning the system gives the enterprise the right to change it. Architecture determines whether that right is practical to exercise.
A practical build, buy and compose view
The useful decision is not which label applies to the whole system. It is which ownership posture fits each important application layer.
| Layer | Build may make sense when… | Buy may make sense when… | Portability question |
|---|---|---|---|
| Foundation model | The model itself is strategically unique and the enterprise has unusual data and ML capability | General-purpose capability is sufficient | Can another model be introduced without redesigning the application? |
| Business workflow | The workflow contains proprietary process or decision logic | The process is standard and already well served by a product | Can workflow logic be recovered or recreated independently? |
| User experience | Interaction design differentiates the service | A standard product experience is sufficient | Can the interaction flow survive a change underneath it? |
| Enterprise tools | Internal actions require organization-specific controls | A packaged connector satisfies the need | Can the same capability be called from another AI runtime? |
| Retrieval / context | Context assembly is central to application quality | Managed retrieval satisfies quality and control needs | Can source rules, metadata and retrieval logic be reconstructed? |
| Evaluation | Acceptance criteria are business-specific | Vendor evaluation is sufficient for ordinary quality checks | Does the enterprise retain test cases, expected outcomes and history? |
| Runtime / operations | The application requires unusual deployment behavior | Managed operation removes work the enterprise does not need to own | Can the application move without reworking its core business logic? |
| Packaged application | The business process is highly differentiated | The use case is common and speed matters more than customization | What must be recovered or rebuilt if the product is replaced? |
Different rows can carry different answers, which is what makes a composed architecture possible: ownership choices are made separately rather than forcing one philosophy across the entire application.
Control should be spent where change matters
Building everything gives the enterprise more direct ownership but can burden it with capabilities another provider already operates effectively. Buying everything can accelerate deployment but place business-important behavior behind another organization’s product and release boundaries.
Composition creates a middle ground when the interfaces between those choices remain understandable and replaceable enough for the business.
The strongest architecture is neither the one with the highest percentage of custom code nor the one with the longest list of managed services. It is the one that places control where the business needs to make independent decisions and preserves enough portability to change those decisions later.
Build, buy and compose are ownership choices today. Portability determines how expensive those choices become tomorrow.



