Deploying Models in Microsoft Foundry
A team has selected an open model in Microsoft Foundry. Its evaluation results look promising, and the team now wants to make the model available to an application. One person recommends a serverless API deployment because that path supports the model.
Another recommends managed compute because the name sounds more production-oriented. There’s an important detail, though. Managed compute is currently a preview option for selected open-source, partner, and custom models. Which choice is more defensible, and what would you need to verify before calling it production-ready?
That decision isn’t just another round of model selection. Selecting a model asks whether its capabilities and behavior fit the workload. Deployment asks how the application will access that model and what operational arrangement comes with that access.
A strong benchmark result doesn’t decide the deployment method by itself. The team still has to consider support status, infrastructure, networking, billing, and operational characteristics. Two paths may provide access to a suitable model while creating different responsibilities and constraints around it.
In the current Microsoft Foundry documentation used for this lesson, serverless API is the preferred and most capable deployment path for Foundry Models. Serverless doesn’t mean that no computing infrastructure exists. It describes a path where the team doesn’t manage dedicated model-serving compute as part of the deployment choice. The practical attraction is that the application can work with a supported model through an application programming interface, or API, without the team first taking on a managed-compute deployment.
Managed compute is a different option. Microsoft documents it as preview for selected open-source, partner, and custom models. Both parts of that statement matter.
Preview describes the status of the option, and selected describes its availability. You can’t safely turn either word into a universal promise. A particular model’s presence in the catalog doesn’t, by itself, establish that every deployment method is available for that model. Nor does the availability of a preview feature mean your organization should treat it as equivalent to a generally available path for production planning.
There’s also a nearby option called instant access. Microsoft documents instant access as a preview path for trying supported models without first creating a deployment. That makes it useful to distinguish experimentation from deployment.
If the immediate requirement is to try a supported model and observe whether it has the desired behavior, instant access may fit that early investigation. If an application requires an established deployment arrangement, trying the model through instant access hasn’t completed that task. It has answered an earlier question about access and behavior.
So the first boundary is straightforward. Model choice, model access, and model deployment are connected, but they aren’t interchangeable. A model evaluation can support the choice of model.
Instant access can support an early trial for a supported model. A serverless API or managed-compute option determines how the model is made available under a deployment approach. The current AI-901 scope expects you to reason about model deployment and configuration, not merely recognize a model’s name.
A reliable decision begins with the workload rather than the option that sounds most sophisticated. Ask what the application will send, what it must receive, which model capability is required, and what constraints govern the implementation. Then ask whether the candidate model and deployment path actually support that combination. This order matters because a deployment method can’t create a capability the chosen model doesn’t have, and a capable model doesn’t guarantee that every deployment path is available or appropriate.
Return to the team with the open model. Suppose its application sends requests to the model and expects generated responses. The model has already been compared with alternatives for quality and other relevant tradeoffs. The remaining requirement is to choose a supported access path that the team can justify for a production candidate. The team also prefers to avoid preview dependencies unless a preview feature is necessary and accepted for the project.
The first check is support. Is this model supported through serverless API? If it is, that gives the team a documented path that Microsoft describes as preferred and broadest. Next, is managed compute available for this particular model?
The general existence of managed compute isn’t enough because it applies to selected models. If it is available, the team must still account for its preview status. The question isn’t which label sounds stronger. It’s which supported path fits the stated requirement and constraints.
For this version of the scenario, serverless API is the better initial choice. It is supported for the model, it meets the application’s need to call the model, and it avoids selecting a preview path without a requirement that calls for one. That conclusion does not mean managed compute is always wrong. If a selected open-source, partner, or custom model and the workload’s constraints led the team toward managed compute, it could be a candidate. Its preview status would remain part of the decision rather than disappearing because the feature worked in a test.
Now include the operational consequences. The deployment choice affects more than the response text. It can affect the infrastructure arrangement, the networking design, how billing applies, and the operational characteristics the team has to manage. The approved evidence for this lesson establishes those categories, but it doesn’t justify pretending that every organization will see one identical cost or network outcome. The team should compare the documented conditions for its chosen path with its own networking, governance, and billing requirements.
A useful decision record would therefore be more specific than serverless is easier or managed compute is better. It would say that the required model is supported by the selected path, identify whether that path is generally available or preview, and connect the choice to the application’s constraints. It would also name what must be tested. That might include whether the application can reach the chosen model access point, whether valid requests produce the expected kind of output, and whether the observed operational and billing behavior fits the workload’s expectations.
What about instant access? If the team is still asking whether a supported model can produce acceptable responses, instant access may provide a lower-commitment preview path for trying it without creating a deployment first. But it shouldn’t be selected as though it were merely another name for the production deployment. Its purpose in this reasoning chain is different. It can help gather evidence about a supported model before the team establishes the deployment approach required by the application.
The full chain is the business need, the technical capability, the implementation method, and the test result. The requirement describes the needed input, output, and constraints. Capability establishes whether the model and access path can meet them.
Implementation chooses serverless API, preview managed compute, or an appropriate preview trial path where supported. Verification compares observed behavior with the requirement. This prevents product-name recognition from becoming a substitute for technical reasoning.
Verification begins before the first request is sent. The team should state what success will look like. For example, the selected model must be available through the intended serverless path, the application must be able to submit its expected input, and the response must have the required kind of output. The deployment status and support information should agree with the decision record. If the project excludes preview dependencies, a preview label is evidence that the option doesn’t satisfy that constraint, even if a demonstration produces a plausible response.
After implementation, one successful response is useful, but it’s not complete production evidence. It shows that one request produced one result under the tested conditions. The team should compare that observation with the intended workload.
Did the application use the deployment path that was actually approved? Did it send representative input? Was the output usable for the scenario rather than merely fluent or impressive? Did the observed operational behavior align with the constraints the team had identified?
This is where a common misconception causes trouble: all models in Foundry use one identical deployment method. Imagine an engineer assuming that any model visible in Foundry can be handled through the same procedure. The engineer reads about managed compute, creates a design around it, and only later checks whether the chosen model and option form a supported combination. The error happened before configuration. A broad product-level statement was treated as model-specific evidence.
The documented boundaries expose the mistake. Serverless API is described as the preferred and most capable path, not as the only conceivable path. Managed compute is preview and applies to selected open-source, partner, and custom models.
Instant access is also preview and lets someone try supported models without first creating a deployment. Those differences would be unnecessary if every model used one identical method. The correct rule is to check the documented options and status for the model and workload you actually have.
The lowest-complexity validation is often a direct support and status check followed by a representative request. First, confirm that the intended option is available for the selected model and note whether it’s preview. Then use the intended access path with input that resembles the application’s real input. Compare the output and observed behavior with the success criteria. This test distinguishes a supported decision from an assumption without requiring the team to build the entire application first.
Suppose the model works through instant access, and someone concludes that the production design has been validated. The result is encouraging, but the conclusion is too broad. The observation supports a narrower statement: the supported model produced the tested behavior through that preview access path. It doesn’t establish that the team has created the intended deployment, satisfied the production networking design, or confirmed the relevant billing arrangement. Those questions belong to the deployment choice and its operational validation.
The same discipline applies when serverless API succeeds. A valid response supports the conclusion that the tested request reached the model and returned output. It doesn’t prove that every expected input will behave correctly or that every workload constraint has been satisfied. If evidence conflicts with the prediction, revisit the model capability, the chosen service path, the deployment or access status, the request, the configuration, and the expected output. Don’t preserve the original conclusion by ignoring the observation that challenged it.
Troubleshooting should end with a revised claim that matches the evidence. The team might say, “This model is supported through serverless API, and representative requests returned the expected kind of output. Managed compute was not selected because it is a preview path and wasn’t required by this workload.” That’s much stronger than saying, “Foundry models are serverless,” which overgeneralizes, or “Managed compute is production-ready,” which ignores the documented preview qualification.
This decision pattern fits into a broader Foundry workflow. Earlier reasoning identifies the workload and its required AI capability. Model comparison then considers evidence such as quality, safety, cost, throughput, feature support, and evaluation with relevant data. Deployment follows those decisions. It turns the selected capability into something an application can access, while introducing infrastructure, networking, billing, and operational considerations that model comparison alone doesn’t settle.
That sequence also explains why the most capable model isn’t automatically paired with the most elaborate deployment option. Capability and deployment solve different parts of the problem. A model may be an excellent fit for the desired output, while a proposed deployment path is unsupported, preview when the project requires otherwise, or inconsistent with operational constraints. Conversely, a broadly supported deployment path can’t rescue a model whose output doesn’t meet the workload requirement.
When reading a scenario, start by finding the decisive clue. If the clue says the team wants the documented preferred and most capable deployment path for a supported Foundry Model, serverless API is the leading candidate. If it specifies selected open-source, partner, or custom models and explicitly allows a preview compute option, managed compute may deserve consideration. If the goal is to try a supported model without first creating a deployment, the documented preview option is instant access. Similar words such as access, deployment, and compute don’t erase the differences among those requirements.
Then state why the rejected option doesn’t fit. In the team’s production-candidate scenario, managed compute isn’t rejected because preview features can never work. It’s rejected because the team doesn’t require that path and prefers to avoid preview dependencies.
Instant access isn’t rejected as useless. It’s separated from the deployment decision because the team now needs an application deployment rather than only a trial. That explanation preserves the legitimate purpose of each option while still making a clear choice.
Next, connect the option to its consequences. If two implementation paths can expose a suitable model, compare more than model output. Ask what infrastructure arrangement each path creates, what network requirements have to be satisfied, how billing applies, and what operational behavior the team must validate. These aren’t afterthoughts. They’re part of determining whether a technically available option is suitable for the intended environment.
Preview status deserves equally careful language. Preview doesn’t mean imaginary, and it doesn’t mean automatically suitable. It is a documented status that should remain visible in architecture and production-readiness decisions. If a question or project gives a constraint against preview features, that constraint can decide between otherwise plausible options. If preview is permitted, the team still needs to verify support for the selected model and test the behavior required by the workload.
Production readiness is therefore a conclusion built from evidence, not a synonym for deployment created. A team needs a supported model and path, a clear account of preview status, an implementation that fits its operational constraints, and observed behavior that matches the intended workload. The exact evidence will depend on the application. At a minimum, it should show that the expected input reaches the intended model through the selected path and that the output satisfies the defined requirement under representative conditions.
You can express the reasoning in one connected explanation. “The application needs this model capability and the model supports the required input and output. We selected serverless API because it is a supported path and is documented as the preferred and broadest option. We didn’t choose preview managed compute because the workload didn’t require it and the project avoids preview dependencies. We’ll verify the decision with representative requests and confirm that the observed operational conditions match our networking, billing, and production constraints.”
That explanation is better than memorizing a table without context. It identifies the clue, makes the choice, rejects an alternative for a relevant reason, and names the evidence needed to trust the result. The same structure still works when the answer changes. A different model, a requirement to try before deploying, or an accepted preview dependency could lead to another option. The method remains stable even when the product choice doesn’t.
It also keeps uncertainty honest. A successful trial can establish what happened in that trial. Documentation can establish whether an option is described as supported, preferred, broad, selected, or preview. Neither one alone proves that an entire production workload will meet every requirement. The team combines documented boundaries with representative observation, records what has been shown, and leaves unsupported conclusions open for further validation.
For the original team, the defensible decision is now clear. Choose the supported serverless API path for the production candidate because it fits the requirement and avoids an unnecessary preview dependency. Keep managed compute in view as a preview option for selected models, not as a universal upgrade. Use instant access only if the team needs the distinct preview path of trying a supported model before creating a deployment. Then judge the chosen path by what the application actually requires and what the team can observe.
A deployment decision is sound when the model, access path, and workload constraints all agree. Serverless API is the documented preferred and most capable path, while managed compute and instant access carry preview qualifications and serve different requirements. Those labels guide the choice, but they don’t replace verification.
Confirm that the option supports the selected model, account for infrastructure, networking, billing, and operational consequences, and test representative input through the intended path. The essential habit is to avoid assuming that every Foundry model deploys in the same way. Start with the requirement, choose a documented capability, and trust the result only as far as the observed evidence supports it.
Before moving on, ask yourself: When would preview status or dedicated capacity change your choice between serverless API, managed compute, and instant access? Use the companion episode reference for serverless API, managed compute, instant access, preview status, infrastructure, networking, billing, and operations. This lesson was produced by Bare Metal Cyber dot com.