Auto Activation for SaaS Private Offers is a Game Changer!
Shout out to Microsoft Marketplace for launching AUTO ACTIVATION for SaaS private offers. This has simplified our sales operations for Microsoft Marketplace private offers, as well as dramatically improved our seller and customer experience with by eliminating the #1 reason we've historically seen block customers from completing Marketplace SaaS private offer procurement. Auto activation for private offers allows customers to skip the step of going to our SaaS landing page and activate Marketplace SaaS billing by having to SSO with their AAD. The problem with this step is that most of our customers are in regulated industries, and their AAD admins do not allow SSO on SaaS landing pages without enabling profile sharing, which requires a Global Admin to enable. We've encountered far too many times where our customer is scrambling to find their Global Admin so that they can complete the final steps to finish the steps to activate Marketplace SaaS billing. This also puts our sellers in the awkward position of having to help customers diagnose and troubleshoot the situation, which as a rule they are not equipped to, or find a Microsoft resource to help. Now, with this new feature the whole SSO to our SaaS landing page and associated problems are eliminated. Ever since we started using it our customers' procurement experience has been faster and smoother. I'm looking forward to more improvements to the Marketplace experience! Here is the feature: https://learn.microsoft.com/en-us/partner-center/marketplace-offers/create-new-saas-offer-plans#configure-auto-activationDesign CI/CD for AI apps and agents selling through Microsoft Marketplace
In the previous post, Design observability for AI apps and agents selling through Microsoft Marketplace, we focused on observability—making AI app and agent behavior visible and explainable. Execution paths, retries, degradation patterns, and agent decisions can now be observed across environments and tenants. With that visibility in place, a new challenge emerges: how do you safely modify an AI system whose behavior you can now observe? You can always get curated step-by-step guidance through building, publishing and selling apps for Marketplace through App Advisor. This post is part of a series on building and publishing well-architected AI apps and agents in Microsoft Marketplace. The series focuses on AI apps and agents that are architected, hosted, and operated on Azure, with guidance aligned to building and selling solutions through Microsoft Marketplace. Using continuous integration/continuous delivery (CI/CD) to control AI system evolution AI apps and agents introduce numerous novel ways that production behavior can change. In addition to application code, updates to configuration, prompts, models, and guardrails, agent logic can alter execution, cost, and outcomes—often immediately and across tenants. CI/CD defines how these changes reach production. Without a structured delivery path, behavior‑shaping updates risk entering runtime without validation or recovery paths, making system behavior difficult to explain or reverse once customers encounter it. AI solutions are typically built and operated as cloud applications. Software delivery of cloud services, and the supporting components that enable it, remains part of the CI/CD pipeline, and any instability in these foundational components directly propagates into AI behavior. AI systems add two additional sources of change that require explicit control. MLOps governs model evolution. Agents introduce further variability, as agent logic and configuration evolve. CI/CD is what prevents these change vectors from interacting unpredictably across both publisher and customer environments. Core CI/CD requirements for AI apps and agents For AI apps and agents, CI/CD determines whether deployment strategies can be applied safely. Progressive rollouts, ring deployments, feature flags, and kill switches all rely on pipelines that isolate change, validate behavior, and support rollback. Observability provides insight into behavior; CI/CD controls when and how that behavior is allowed to change. CI/CD must reliably provision, configure, and promote cloud native infrastructure, including but not limited to front-end services, APIs, storage, identity, and networking across environments. Agent behavior depends directly on the stability of the platform it runs on. AI systems introduce additional CI/CD requirements through MLOps and agents. Model versions, routing logic, and evaluation configurations must move through pipelines as deployable artifacts, with isolation, validation, and rollback built in. Changes to models affect latency, cost, and outcomes even when application code remains unchanged, making promotion controls necessary at the model layer. A well-run CI/CD pipeline should positively impact AI models and agents in the following ways: Change isolation ensures code, prompts, models, and configuration evolve independently. Artifact versioning beyond code treats prompts, policies, tools, and models as release assets. Behavioral validation evaluates outcomes, constraints, and patterns rather than single responses. Safe promotion controls gate model and agent releases based on observed behavior. Rollback readiness allows fast reversion when model or agent behavior degrades. Building behavioral baselines for AI solutions using CI/CD Before an AI system is built by a pipeline, it is built by a team. CI/CD build pipelines are where these contributions are stitched together. Product managers define scope and constraints. UX designers shape how behavior is experienced. Full‑stack engineers assemble application logic. AI engineers wire reasoning and tools. Data engineers and data scientists curate data and models. In AI systems, a build does more than compile code. It captures a shared agreement across roles about what the system is expected to do. Application code, orchestration logic, prompts, configuration, guardrails, routing rules, and trained or fine‑tuned models are assembled into a single versioned artifact. That artifact represents a coordinated snapshot of intent, behavior, and constraints. This coordination must declare which models, prompts, policies, and tool definitions are included. Implicit dependencies—such as dynamically changing prompts or unpinned models—break shared understanding across teams and introduce behavior changes without acknowledgement. A successful build confirms that contributions from multiple roles are compatible and executable together. It does not decide when customers see the change. That decision belongs later, where behavior can be evaluated deliberately, enforced by build pipelines that are separating assembly from release. Testing AI solutions with CI/CD pipelines When an agent is updated, the first task is straightforward: the agent’s code changes. Logic is refined, tools are added, limits are adjusted. That change moves through the CI/CD pipeline, where it is built, packaged, and validated in isolation. At this point, the focus is narrow—does this agent compile, configure, and execute as expected? The second step widens the lens. The update now moves through testing aligned to the layers beneath it. For cloud solutions, tests confirm the platform still behaves as assumed: infrastructure provisions correctly, APIs and identity boundaries remain intact, and dependencies remain reachable. These tests ensure the environment can support execution before behavior is evaluated. Next, MLOps tests assess whether model behavior still aligns with system expectations. New model versions, routing logic, or provider changes are evaluated for cost, latency, and outcome consistency. The goal is not identical responses, but bounded behavior within known limits. Finally, testing shifts to the agentic system as a whole. Other agents need to be made aware of the new capabilities. When you go to update the agent the first job you have to do is update the agent code. The second job you have to do is to use your CI/CD pipeline to build, test and release that code. The third job is to test that the entire agentic system is running smoothly together. At this stage, testing answers a different question: not does the agent work, but does the system still work together. CI/CD release management as team coordination Once testing confirms that behavior remains within expected bounds, release management determines how changes are introduced and observed under real conditions. In AI systems, release management must reflect where change originates and how risk propagates across layers. Within the cloud services that support the AI solution, release management focuses on scope and blast‑radius control. Examples include staged rollout of infrastructure updates, controlled exposure of new API versions, and limiting configuration changes to specific environments or tenants before going global. These steps allow both publisher and customer teams to observe stability and dependency behavior under load. For MLOps, release management governs behavioral shifts introduced by model changes. Common patterns include routing a small percentage of requests to a new model version, limiting exposure to specific customer segments, or restricting usage to defined request types. This allows teams to compare cost, latency, and outcome patterns before expanding exposure. For agents, release management controls how new behaviors surface. Prompt updates, tool access changes, or guardrail adjustments may be released to specific workflows, tenants, or traffic slices. This makes it possible to observe planning depth, retry behavior, and termination patterns without affecting all users simultaneously. Rollback readiness remains essential. Release paths must allow fast reversion using version pinning or traffic shifting rather than full redeployment. Release management creates space to observe, adjust, and respond before changes reach full Marketplace scale. Deployment as a shared boundary Effective deployment pipelines ensure that software, models, and agent behavior enter production together, with changes explicitly acknowledged and observable. Versioning and rollback remain available, but deployment defines the moment when coordinated decisions become customer‑visible. Cloud service—For the software, deployment governs application code and supporting platform changes. These remain necessary foundations. Application binaries, infrastructure templates, runtime configuration, and orchestration must enter production in a known, versioned state so operational behavior can be correlated with specific changes. MLOps—Model version updates, routing rules, provider switches, and evaluation configurations can change system behavior without modifying application code. Deployment pipelines must therefore treat these artifacts as deployable units, subject to the same versioning, promotion, and rollback mechanics as software releases. Agent—Deployment includes behavior‑defining inputs such as prompts and system messages, tool definitions and permissions, guardrails, and execution limits. Changes directly affect how agents plan, execute, and terminate work. Allowing these inputs to change outside deployment pipelines breaks traceability and weakens accountability across teams. How CI/CD best practices positively impact marketplace readiness Customers expect updates to arrive in predictable ways. They expect that behavior changes can be explained, that issues can be reversed without prolonged disruption, and that outcomes remain consistent across trials and production use. CI/CD pipelines make these expectations achievable by ensuring changes are versioned, staged, and observable as they move through environments. Reliability depends on limiting how far unstable behavior propagates. Billing accuracy depends on knowing when changes alter execution paths, token usage, or metering logic. Compliance depends on being able to identify which versions of software, models, and agent configurations were active at a given time. Offer type shapes how CI/CD is applied. For transactable SaaS offers, CI/CD operates entirely within the publisher’s environment. For container offers and Azure Managed Applications, deployment boundaries extend to customer environments requiring a CI/CD hand-off between publisher and customer pipelines. Publisher CI/CD responsibilities for AI solutions Publishers must define what constitutes a deployable change. Updates to software, models, prompts, agent configuration, guardrails, or limits should not enter customer environments or generally available code implicitly. Each change that can influence behavior must flow through the publisher’s CI/CD pipelines so it can be versioned, observed, and reversed if necessary. Additionally, CI/CD pipelines require validation and approval before promotion, ensuring that behavior‑altering updates do not reach customers without visibility or control. Publishers are also responsible for communicating behavior changes. Customers should be able to understand when updates affect outcomes, performance, or cost profiles. Customers should never experience silent behavior shifts, undocumented updates, or releases that cannot be recovered cleanly. When those occur, trust erodes quickly. In this context, CI/CD is part of how publishers establish reliability, accountability, and trust with Marketplace customers. Customer’s responsibility: CI/CD across environments (Dev / Stage / Prod) While publishers own CI/CD pipelines, customers play an important role in how AI systems are evaluated and adopted across environments. AI behavior often manifests differently across Dev, Stage, and Prod because operating conditions change as systems move toward real usage. As environments scale, dependency interactions increase, traffic patterns diversify, and tenant behavior becomes less predictable—revealing execution paths and constraints that are not exercised earlier. These differences affect how behavior appears during evaluation and rollout. To keep behavior interpretable across environments, pipeline structure matters. CI/CD pipelines, validation steps, and promotion criteria should operate consistently so signals observed earlier can be understood later. When these mechanics diverge between environments, it becomes difficult to attribute changes in behavior to specific updates or conditions. Staging environments serve as a behavioral proving ground. They allow customers to observe retries, limits, degradation paths, and cost behavior under conditions that more closely resemble production. Trials often run against production‑like configurations, which means CI/CD gaps surface early. When behavior differs from expectations, the consistency of pipelines determines how quickly teams can diagnose and respond. What’s next in the journey With CI/CD establishing control over how AI systems change, the next focus is how those changes are introduced safely at runtime. The following posts cover deployment strategies, progressive rollouts, and operational patterns that allow AI apps and agents to evolve while remaining stable, observable, and ready for Marketplace scale. Key resources See curated, step-by-step guidance to help you build, publish, or sell your app or agent (no matter where you start) in App Advisor Quick-Start Development Toolkit can connect you with code templates for AI solution patterns Microsoft AI Envisioning Day Events How to build and publish AI apps and agents for Microsoft Marketplace Get over $126K USD in benefits and technical consultations to help you replicate and publish your app with ISV SuccessDesign observability for AI apps and agents selling through Microsoft Marketplace
In the last post, API resilience and reliability patterns for AI apps and agents, we focused on what happens when AI systems encounter failure—and how resilient execution paths keep that failure contained. Timeouts fire with intent. Retries stay bounded. Circuit breakers provide overload protection. When resilience is designed well, your system continues to function even as conditions change, forming the foundation of AI reliability engineering. You can always get curated step-by-step guidance through building, publishing and selling apps for Marketplace through App Advisor. This post is part of a series on building and publishing well-architected AI apps and agents in Microsoft Marketplace. The series focuses on AI apps and agents that are architected, hosted, and operated on Azure, with guidance aligned to building and selling solutions through Microsoft Marketplace. Observability for AI systems AI apps and agents are shifting traditional observability, which was designed for systems based on simple assumptions, where requests followed linear paths and workloads behaved predictably. Execution in AI systems consumes tokens at a highly variable rate rather than fixed compute units. Requests unfold across multiple reasoning steps. Agents perform work that spans APIs, models, retrieval layers, and applications. A single interaction may pause, branch, retry, or exit early depending on inferred intent, context, and constraints. Instead of asking whether services are running, observability for AI systems asks: what is the system doing right now—and why? Is an agent spending its time reasoning, waiting on dependencies, retrying tool calls, or exiting early due to enforced limits? Is cost increasing because value is increasing, or because execution paths are expanding without progress? AI observability requirements shift the focus in the following subtle, but critical ways: From resource availability to workflow state From performance metrics to signals From incidents to patterns Core observability dimensions for AI apps and agents Once observability shifts toward understanding behavior, clarity comes from tracking state across the agents in the workflow. For AI apps and agents, observable indicators, such as those detailed below, show how work unfolds and changes during real usage—especially in trials and early adoption: Execution flow shows how a request moves through agents, tools, and workflows. This highlights where execution progresses smoothly, where it slows, and where it concludes early. This makes agent outcomes explainable and keeps behavior consistent across tenants. Cost and token behavior reveals how execution translates into consumption. Token usage per request, per agent step, and per retry shows where value is being delivered and where execution paths expand without proportional benefit. This insight connects runtime behavior directly to Marketplace billing expectations and evaluations. Latency and wait states distinguish active processing from time spent waiting on dependencies. Seeing where time is consumed helps explain slow experiences and guides decisions about optimization, caching, or resilience improvements. Failure classification provides structure when systems degrade and supports effective AI incident management. Separating tool failures from planning failures, and transient issues from terminal exits, keeps investigations focused and prevents protective behavior from being misread as instability. Tenant‑level patterns surface how behavior repeats at scale. Uneven load, and recurring degradation often appear first during trials and shape the customer's perception. Together, these dimensions turn telemetry into understanding—supporting clearer conversations, faster triage, and predictable execution as usage grows. Why observability matters By this point in the journey, your AI app or agent has implemented bounded execution paths, cost controls, and quality of service safeguards. As a result, failure degrades gracefully instead of spreading. These resilience techniques determine how your solution behaves under pressure. The data gathered from observability platforms like Application Insights and Azure Monitor explains why it behaves that way. For AI and agentic systems, infrastructure health alone rarely answers the questions that matter. Services can be up, CPUs can be idle, and queues can look healthy while agents loop inefficiently, retries quietly expand cost, or workflows exit early without delivering value. From the customer’s perspective, the experience feels inconsistent even though the platform appears stable. AI app observability closes this gap by revealing system behavior rather than system status. It shows how requests move, where work concentrates, and how constraints shape outcomes. At Marketplace scale, these patterns repeat across tenants and trials. What appears once during an evaluation often appears again as adoption grows. Observability connects runtime behavior back to the design choices introduced in earlier posts: Usage‑based billing introduced variability in consumption Performance optimization introduced tradeoffs among latency, quality, and cost Resilience patterns introduced controlled failure and bounded execution Observability allows you to explain outcomes during trials, validate assumptions as usage grows, and support post-launch AI operations confidence across customers and environments. Without this visibility, teams react to symptoms. With it, they recognize patterns. From execution paths to behavioral signals Observability begins at the same place resilience begins—API boundaries. These boundaries define where responsibility shifts and where behavior becomes visible. Observability focuses on signals that explain decisions made by the system as it executes instead of relying on raw logs that describe isolated events. Every resilience mechanism emits behavioral signals. Viewed together, these signals provide far more value than logs alone. Logs answer whether something happened. Behavioral signals explain why it happened and how the system responded. Circuit breakers change state as load builds and recedes. Retry loops show whether failures resolve quickly or exhaust their limits. Timeout enforcement reveals where dependencies slow execution. Fallback paths and early terminations show how the system protects itself while preserving outcomes for customers. This perspective matters most for agents. Agent execution unfolds as a series of choices—plan, call a tool, retry, exit early—rather than a single request‑response cycle, which requires monitoring AI agent behavior to remain understandable and consistent at scale. Observability that tracks these decisions makes agent behavior understandable, consistent, and defensible as usage grows across customer tenants. Observability at the agent layer As AI systems become more agent‑driven, observability needs to move closer to where decisions are made. Agents introduce variability by design. They plan, adapt, and choose workflow paths dynamically. Without first‑class visibility into that behavior, execution can appear unpredictable even when the underlying system is healthy. Observability at the agent layer acts as the feedback loop that keeps execution safely bounded. It shows how agents use the freedom you give them—and where that freedom begins to stretch into inefficiency. Observability follows how the agent did its job instead of treating the agent’s interaction as a single outcome. Several indicators help make agent behavior understandable. Step count per request reveals how much reasoning effort a prompt requires. Planning iterations show whether an agent converges quickly or cycles through alternatives. Tool invocation frequency highlights when agents rely heavily on external systems. Early exits compared to full completion explain whether limits and fallbacks activate as designed. Taken together, these indicators help distinguish healthy exploration from inefficient reasoning and degraded execution. An agent exploring briefly before converging adds value. An agent looping through tools without progress signals pressure, uncertainty, or dependency issues. This distinction reinforces a core principle of agentic systems: models reason probabilistically, adapting to context as it changes. Your system observes deterministically—measuring execution, enforcing boundaries, and clarifying outcomes. When those roles stay separate and well‑instrumented, agent behavior becomes transparent, predictable, and ready for Marketplace scale. Observability across environments The type of Marketplace offer you choose shapes what observability customers expect and how responsibility is shared. For SaaS offers, publishers typically own end‑to‑end execution. Observability centers on agent behavior, workflow completion, token usage, latency, and dependency impact across tenants. Publishers rely on consistent signals—often surfaced through tools like Azure Monitor, Application Insights, and Microsoft AI Foundry—to explain how requests behave as scale and load increase. For container‑based offers and Azure Managed Applications, observability expectations are more distributed. Publishers expose clear execution outcomes, limits, and failure signals at application boundaries. Customers, in turn, observe infrastructure health, scaling behavior, and downstream systems within their own environments. This separation ensures each party has visibility into what they control without creating ambiguity. Learn more about Choosing your marketplace offer type for AI Apps and agents. Execution behavior differs across environments for predictable reasons. Scale increases, tenant mix broadens, and external dependencies behave differently under real load. What must stay consistent is how behavior is interpreted. Signal definitions, thresholds, and failure classification should mean the same thing in Dev, Stage, and Prod. Learn more about designing a reliable environment strategy for Microsoft Marketplace AI apps and agents. Staging environments are where this consistency is validated. Observing retries, timeouts, and graceful degradation before production prepares you for Marketplace evaluations, which often resemble production conditions. Observability gaps tend to appear first during customer evaluation—when clarity matters most. Publisher and customer visibility boundaries Purpose: Parallel Post #13 responsibility clarity, now for observability As observability matures across environments, clarity around responsibility becomes essential. For Marketplace solutions, trust grows when publishers and customers each see what they own—and understand where that visibility ends. Publishers are responsible for instrumenting execution paths end to end. That means making workflows traceable, limits visible, and failure modes explainable. Observability should surface behavior—how requests progressed, where execution concluded, and why—rather than exposing raw internal errors that require insider knowledge to interpret. Customers focus their observability on what they control. This includes monitoring downstream systems, infrastructure behavior, and environment‑level alerts within their own estate. When visibility aligns with ownership, teams can act quickly and decisively. Exposing too much internal detail can overwhelm customers and blur accountability. Observing too little behavior creates friction, especially when issues cross boundaries and lack context. Clear visibility enables faster triage, sharper ownership boundaries, and fewer escalations rooted in ambiguity. Observability as an enabler for scale, billing, and trust From a customer’s perspective, observability answers two fundamental questions: Can I understand what happened? and Can I trust this at scale? When the answer to both is clear, observability becomes part of the value your Marketplace offering delivers. When system behavior is visible and explainable, customers gain confidence that adoption and growth will remain predictable. Observability directly supports usage‑based billing by tying execution behavior to measured consumption. Clear visibility into token usage, retries, and execution paths helps validate how usage is calculated and supports transparent billing conversations. It also enables ongoing performance tuning and caching strategies by showing where latency accumulates, where work repeats, and where optimization delivers measurable impact. Observability reinforces confidence in resilience mechanisms, confirming that limits, fallbacks, and degradation paths activate as designed under real‑world conditions. Beyond validation, observability creates a continuous feedback loop. Execution data informs pricing adjustments, guides changes to limits, and helps refine default configurations as customer behavior evolves. What’s next in the journey With execution behavior observable and explainable, the focus shifts to how AI systems are operated safely as change accelerates. The upcoming posts will discuss deployment strategies, CI/CD pipelines for agents, and progressive rollouts build on this foundation—ensuring AI apps evolve confidently as usage and expectations grow. Key Resources See curated, step-by-step guidance to help you build, publish, or sell your app or agent (no matter where you start) in App Advisor Quick-Start Development Toolkit can connect you with code templates for AI solution patterns Microsoft AI Envisioning Day Events How to build and publish AI apps and agents for Microsoft Marketplace Get over $126K USD in benefits and technical consultations to help you replicate and publish your app with ISV SuccessHow to get heard by Microsoft and win more together
At Ultimate Partner LIVE Bellevue, May 11-13, some of the sharpest practitioners in the Microsoft ecosystem are coming together to share what works. These are candid, practitioner-led sessions built for senior leaders who need to walk away with something they can use, not a framework to revisit in six months. 🏛️ Sessions Worth Your Time 💰 Marketplace Meets AI: The New Route to Partner Revenue Cyril Belikoff, VP Microsoft Azure · Jon Yoo, CEO Suger Cyril Belikoff helped architect the unified Microsoft Marketplace and launched the resale enabled offer, which lets channel partners bundle software development company solutions and transact against Azure commit. Within the 1st week of GA, partners were already processing deals at scale. Cyril joins Vince Menzione and Jon Yoo, CEO of Suger, on Day 1 to cover where the AI-driven marketplace motion is heading and what partners need to do now to capture their share of the revenue flowing through it. Cyril’s advice for the partner still on the sideline is direct: do not try to boil the ocean. Get listed. Create offerings. Figure out 1 or 2 deals, transact them, and see the opportunity. This session gives you the map. 🎯 From Attention to Trust: The New Rules of Hyperscaler Go-To-Market Ashleigh Vogstad, CEO Transcends · Leigh Ann Campbell, Principal REV Alliances We are no longer in an attention economy. You are not competing to be seen. You are competing to be trusted, and the shift has a specific mechanism. AI agents are already making procurement decisions using verified signals: co-sell track records, Partner Center data, marketplace history, certifications. The partners building that record now are building an advantage that compounds quickly and is difficult to replicate later. Leigh Ann Campbell has driven over $200 million in influenced and net-new revenue through the Microsoft partner ecosystem. She knows what happens to a referral the moment it lands in Partner Center and what you need to do to make sure it does not die there. Ashleigh Vogstad, CEO of Transcends, brings the broader GTM lens on how the trust economy is changing what buyers respond to and where most partner marketing misses the mark. 🚀 Partner to Pipeline: Activating your GTM Strategy Reis Barrie, CEO Carve Partners · Greg Goldkamp, Sr. Director Microsoft This is the rare combination of a partner who has built real pipeline through Microsoft’s co-sell motion and a Microsoft leader who can tell you directly what gets field attention and what gets ignored. Most software companies approach co-sell as a relationship exercise. The ones generating real pipeline treat it as a system. They know which solution plays are active in the current fiscal year. They show up in seller conversations before a deal is open. They make it easy for a Microsoft seller to bring them in because the pitch is already mapped to what that seller is measured on. This session covers how to build that system, from first registration in Partner Center through closed pipeline. 🔗 From Connector to Catalyst: Today’s Alliance Manager Erin Figer, Founder CORE Consulting · Christine Bongard, CEO The WIT Network · Steven Karachinsky, CEO ZIRO Erin Figer helped build the co-sell practices at Microsoft, AWS, and Google Cloud when those programs were still being designed. She brings a reframe that changes how the best alliance teams operate: before you can market with a hyperscaler, you have to market to them. Treat Microsoft like a customer. Understand their priorities, their fiscal calendar, their field incentives. Build the internal credibility that gets you pulled into deals instead of chasing them. Joined by Christine Bongard and Steven Karachinsky, this session covers what the transition from connector to catalyst looks like in practice and what separates the alliance managers who generate revenue from those who manage relationships. 💡 Why the practitioner track matters These are not panel discussions with safe answers. This audience asks direct questions, and the speakers in these sessions are prepared to give direct answers. These sessions run across both days alongside 2 full tracks of mainstage content covering marketplace, distribution, AI strategy, and Microsoft’s channel priorities heading into FY27. 📅 UP LIVE Bellevue · May 11–13, 2026 InterContinental Hotel, Bellevue, WA 🌟 Exclusive discount for Microsoft partners Use code ULTIMATEVIP50 at checkout for a special discount reserved for Microsoft partners. 👉 Register for UP LIVE Bellevue Ultimate Partner® is the premier independent platform for technology partnership leaders, uniting the hyperscaler ecosystem to achieve their greatest results through partnering. An official Microsoft GPS recognized community.
Marketplace offers as transactable and azure benefit eligible
Query about Marketplace listings - I want to upload a new offer as SaaS. I want to make sure it's transactable and also have the azure benefit tag added to it. I have the banking and tax profile approved and completed. I'm unable to find how do I get the Azure benefit eligible tagged to this offer (or is there a pre-requisite). I have reviewed the Marketplace best practices but unable to find how do I exactly go about doing it.Design predictable AI performance to scale selling through Microsoft Marketplace
Trade-offs in AI performance: latency, quality and cost Imagine a software company launches a customer trial for its new AI assistant through Microsoft Marketplace. The trial begins smoothly — until more complex queries take longer than a few seconds to return a response. The cause isn’t model failure. It’s an unbounded Retrieval‑Augmented Generation (RAG) pipeline retrieving 50 documents per query before synthesizing an answer. Latency increases. Runtime token usage expands. Trial‑stage infrastructure cost rises immediately. This exposes the core runtime tradeoff in enterprise AI systems: Latency ↔ Quality ↔ Cost Improving response quality often increases retrieval depth. Increasing retrieval depth expands token usage. Expanded token usage drives both cost and latency upward. This post is part of a series on building and publishing well-architected AI apps and agents in Microsoft Marketplace. The series focuses on AI apps and agents that are architected, hosted, and operated on Azure, with guidance aligned to building and selling solutions through Microsoft Marketplace. You can always get curated step-by-step guidance through building, publishing and selling apps for Marketplace through App Advisor. How traditional cost model assumptions break down for AI In classic software models, you expect predictable runtime costs such as license allocations, storage, compute time, bandwidth consumption, etc. But in AI-powered systems, that stability gives way to new complexities driven by token-based cost structures. These costs scale in unexpected ways, depending on the length of generated outputs, the depth of information retrieval, the number of reasoning steps an agent performs, and how often external tools are invoked. Consider the RAG pipeline scenario: retrieving five documents for a single query might create a 3,000-token prompt. If the pipeline instead pulls 50 documents, that prompt balloons to 15,000 tokens—before the AI even begins to infer an answer. And the unpredictability doesn’t stop there. Agent orchestration can introduce even more variability. Planning steps may stretch or shrink depending on the query, tool-calling systems might retry failed executions multiple times, and multi-branch workflows can run in parallel, all amplifying token consumption and cost. Keep costs bounded without sacrificing quality While unpredictable token usage and orchestration steps can quickly escalate infrastructure costs in AI-powered systems, design choices can prevent runaway expenses without compromising the quality of responses. To achieve this, engineers must balance procurement expectations set by pricing with real-time operational controls. For instance, use a multi-model tiered routing strategy to allow less complex queries to be handled by lightweight models, reserving advanced reasoning models for more demanding tasks. Combining this with token budgeting strategies—such as per-session caps and API Management token-limit policies—ensures that each interaction remains within defined boundaries. Cost-aware orchestration paths become essential when running AI workloads across multiple tenants, especially when retries and multi-branch workflows threaten to multiply inference consumption. By calibrating runtime guardrails to performance and cost signals, AI systems can be designed to fail gracefully and predictably, preventing ambiguous and expensive failures. Ultimately, the goal is to deliver high-quality results at scale, maintaining control over both costs and performance as usage grows. Achieving predictable latency: Business best practices across each layer For enterprise AI systems, ensuring fast and consistent response times—while balancing quality and cost—is a top priority. Predictable latency requires intentional design at every layer of your architecture. Interaction Layer: Set clear boundaries for incoming requests using Azure API Management rate‑limit and quota policies, such as rate-limit-by-key, scoped per subscription or tenant. These controls cap request throughput and request volume over time, preventing traffic spikes from overwhelming downstream AI services and ensuring consistent, predictable response behavior across tenants. Orchestration Layer: Define and restrict system execution paths. Limit reasoning depth in workflows so complex operations don’t unexpectedly slow things down. This keeps your business processes running smoothly and predictably. At the API boundary, Azure API Management can enforce deterministic routing, retry limits, and timeout policies, while backend orchestration services such as Azure Durable Functions or Logic Apps manage multi‑step workflows with explicit bounds on execution depth and retries. Model Layer: Choose models based on expected concurrency needs. Use fallback routing to redirect traffic during busy periods—so users don’t experience delays. Rely on Azure OpenAI Provisioned Throughput Units (PTUs) for steady baseline performance and enable PAYG overflow to handle temporary surges without sacrificing speed. Microsoft AI Foundry can be used to centrally manage model selection and routing policies, enabling consistent fallback strategies and governed use of multiple models across agents and workloads. Retrieval Layer: Optimize your document indexing and narrow the scope of data being searched. This means users get relevant information faster, and your system avoids unnecessary slowdowns. Services such as Azure AI Search enable scoped, indexed retrieval over structured and unstructured content, while integrating with Azure Blob Storage or Azure Cosmos DB as source data stores to support predictable, low‑latency access for RAG‑based AI workflows. Data Layer: Keep your compute and storage resources close together and aligned regionally. By minimizing cross-region data transfers, you reduce latency and boost reliability—critical for enterprise-grade AI. Across every layer, publishers are responsible for designing bounded, predictable defaults, while customers govern configuration, scale, and operational posture—a clear separation that reduces friction, improves trial outcomes, and accelerates Marketplace adoption. By applying these best practices decisively at every layer, software development companies can move beyond isolated optimizations and design AI solutions that behave predictably under real customer load. This approach enables customers to run meaningful trials, validate performance and cost assumptions early, and scale with confidence as demand grows. More importantly, it establishes a repeatable engineering foundation—one that supports faster iteration, clearer operational ownership, and successful commercialization through Microsoft Marketplace. Design caching into your architecture from the start Predictable AI performance relies on caching that’s intentionally designed into the architecture—not added after systems are already under load. In agent‑driven and retrieval‑augmented workflows, caching is foundational to controlling latency, stabilizing runtime costs, and keeping execution behavior consistent as usage scales. Effective designs cache work wherever outcomes are deterministic. Request‑level and semantic caching reduce redundant inference when users submit identical or meaning‑equivalent queries, while Azure API Management paired with Azure Managed Redis enables governed reuse at the intent level. Retrieval pipelines benefit from embedding and retrieval caching, which avoids repeated vectorization and unnecessary search overhead. Within orchestration flows, tool‑level caching ensures stable responses for deterministic calls such as policy checks or configuration lookups, and agent plan caching allows reasoning paths to be reused without re‑incurring planning cost. Caching must be paired with clear invalidation strategies—time‑based expiration, context‑aware refresh, and event‑driven updates—to preserve correctness and trust. In Marketplace deployments, multi‑tenant cache isolation and observability are essential. When caching is visible, governed, and intentional, it becomes a powerful enabler of predictable scale. What’s next in the journey With performance and cost under control, the next question is how your system behaves when something goes wrong. The next post explores API resilience and reliability patterns—because predictable performance only matters if your AI system continues to function through the inevitable failures that occur at Marketplace scale. Key Resources See curated, step-by-step guidance to help you build, publish, or sell your app or agent (no matter where you start) in App Advisor Quick-Start Development Toolkit can connect you with code templates for AI solution patterns Microsoft AI Envisioning Day Events How to build and publish AI apps and agents for Microsoft Marketplace Get over $126K USD in benefits and technical consultations to help you replicate and publish your app with ISV SuccessDesign predictable usage-based billing for AI apps and agents selling in Microsoft Marketplace
Design predictable usage‑based billing for AI apps and agents selling on Microsoft Marketplace Compared to traditional software, pricing and billing feel harder because of the range of AI functionality. They reason, they infer, call tools, process data, all, to complete tasks on the customer’s behalf. If you’re building an AI app or agent to sell in Microsoft Marketplace, usage‑based billing needs to be designed with care, instrumented with intention, and explained in a way customers can trust. This post, along with App Advisor’s curated step-by-step guidance through building, publishing and selling apps for Marketplace, walks through how to do exactly that—without over‑engineering or surprising your customers later. This post is part of a series on building and publishing well-architected AI apps and agents in Microsoft Marketplace. The series focuses on AI apps and agents that are architected, hosted, and operated on Azure, with guidance aligned to building and selling solutions through Microsoft Marketplace. Why billing for AI systems is different Traditional software pricing is usually tied to static entitlements, such as licenses, seats, fixed feature sets and/or a predictable runtime footprint. AI apps and agents don’t work that way. Their cost and value are driven by runtime behavior, such as: How often a model is invoked How many tokens are processed per request How deep reasoning chains go How frequently tools or APIs are called How much data is accessed, transformed, or embedded AI behaviors are subject to change based on the interpretation of prompts and subsequent outputs processed by agents and models. That variability is why pricing AI like traditional software often creates friction—margins erode and customers may lose trust. Pricing decisions should start with business value in mind, not the meter level. Start with plan design before you define meters Plans explain pricing. Meters enforce pricing. Your Marketplace plan is where customers learn what they are buying and how it works. Before you design a single metered dimension, your plan should clearly answer: What AI behaviors are allowed What usage is included What usage becomes billable What limits apply How customers upgrade as they grow An effective plan design typically considers several key factors, such as the distinction between public and private plans, the allocation of included usage versus charges for overages, the balance of base fees against variable consumption, and the provision of clear upgrade paths across different tiers. For instance, if you’re creating an AI support agent, a well-structured plan might offer up to 1,000 resolved conversations each month for a set monthly fee, with additional charges for any conversations beyond that limit and a higher tier that grants access to increased usage allowances. When customers can easily understand what is included, what triggers extra costs, and how they can upgrade as their needs grow, metering feels straightforward and fair. Conversely, when plan details are ambiguous, even accurately measured charges can seem arbitrary, leading to uncomfortable billing discussions. Choose a billing model that matches how your AI behaves When structuring your AI solution’s pricing, begin by evaluating the expected usage patterns and the business value your AI delivers. Actively consider the nature of your agent’s workloads, the variability of customer interactions, and the predictability of operating costs. Flat Fee: Weigh the benefits of flat rate or subscription pricing. Opt for fixed monthly or annual fees when your AI solution operates within defined limits and usage remains consistent. This approach simplifies billing for customers and provides them with clear expectations. Subscription pricing works best for AI agents whose engagement is steady and whose costs don’t fluctuate dramatically. Usage-based (metered): If your AI’s usage varies widely or scales rapidly, usage-based (metered) pricing is often preferable. This model aligns charges with actual consumption, ensuring customers pay only for what they use. To implement it, leverage Marketplace metering APIs to track and bill usage accurately. Consider usage-based pricing when customer demand is unpredictable or your AI’s operational costs increase with higher workloads. Hybrid: For AI solutions that deliver ongoing baseline value but occasionally handle intensive tasks, hybrid models combine the strengths of both approaches. Offer a base subscription for predictable service, then layer in usage charges for overages. This structure is common for agents serving regular needs with intermittent spikes, enabling you to manage cost recovery while giving customers cost certainty. Metering looks different depending on your offer type As you move forward with your plan design and billing model, it’s important to recognize that metering varies significantly based on how your solution is delivered. SaaS offers: Usage tracking is accomplished through Marketplace Metering APIs, allowing you to capture AI-driven activities such as agent task executions, workflow runs, document analysis, or token processing. Your metering should align closely with the customer’s subscription lifecycle, plan tiers, and the included usage, ensuring transparency and consistency as customers progress through different service levels. Container-based offers: You might meter resources like nodes, cores, pods, or clusters—or even application-specific AI dimensions. Accurate attribution across tenants and deployments is crucial, so customers are billed reliably according to their actual consumption. Virtual machine offers: Metering is generally linked to VM runtime or license usage. Although the granularity is often lower than SaaS solutions, billing remains contractually enforced, and publishers must ensure that measurements are dependable and align with customer agreements. Azure Managed Applications: Metering should reflect solution management exclusively, while the underlying infrastructure costs are handled separately through Azure’s billing system. For more about offer types, visit Marketplace Offer Types for AI Apps and agents: SaaS vs Managed App vs Containers. Design metered dimensions customers can actually explain As you refine your billing model for Marketplace offers, it’s vital to consider how your metered dimensions will be perceived and understood by your customers. The most effective dimensions reflect clear, customer-visible value rather than abstract internal system mechanics. For AI-driven solutions, this often means tracking tangible outcomes such as agent tasks executed, successful workflows completed, data objects processed, or AI-assisted actions performed. Choosing these straightforward metrics not only makes invoices easier for customers to interpret but also strengthens your position during billing reviews by tying charges directly to business outcomes. For example, “documents analyzed” is a much clearer and more defensible metric than “token batches processed,” and “resolved workflows” resonates more with customers than “model invocations.” Ultimately, a strong metered dimension is one that a customer can easily explain to their finance or procurement teams. If the charge isn’t readily understandable, it’s a signal to revisit and refine your measurement approach. Track and plan metrics using the Microsoft Marketplace metering service APIs Under‑reporting impacts revenue. Marketplace enforces billing based on what you report. Once you've determined how your solution will be delivered and understood how metering varies by offer type, the next step is to ensure your billing model is both transparent and robust. This is accomplished by tracking your plan and meter metrics through the Microsoft Marketplace Metering Service APIs —a process that not only supports accurate billing but also builds customer trust. Instrumenting usage at runtime is essential: you must reliably capture and report consumption, making sure each event is precisely recorded and associated with the correct subscription and plan. Aggregating this usage and sending it to the marketplace—whether hourly or daily, covering the previous 24 hours—ensures billing remains consistent and defensible. Add metering guardrails to avoid cost surprises As you implement usage-based metering for your Marketplace offers, it’s essential to build guardrails that protect both your business and your customers from unexpected costs. Metering is a critical component of your service reliability, directly influencing customer trust and the overall transparency of your billing model. Ensuring your metering remains both dependable and customer-focused is crucial for maintaining trust and transparency. As you instrument your solution, take care to attribute usage precisely across multiple tenants, so every charge is accurately mapped to the correct customer and subscription. Additionally, aggregating usage on a consistent schedule—such as hourly or daily—not only supports predictable reporting but also helps customers better understand their consumption patterns. These practices lay a solid foundation for metering that supports both your business objectives and your customers’ needs, creating a seamless experience that aligns with the overall goals of your Marketplace offering. Marketplace-ready offerings typically feature: Usage caps that set clear maximums, limiting exposure to unforeseen charges. Soft limits with proactive alerts as customers approach their thresholds. Hard limits to enforce plan boundaries and prevent overages beyond agreed levels. Transparent usage dashboards, giving customers real-time visibility into their consumption. For example, when a customer reaches 80% of their allotted usage, they receive an alert and can decide whether to upgrade their plan, pause usage, or proceed into overage with full awareness—eliminating surprise invoices at month’s end. What’s Next in the Journey After establishing robust billing and metering, the next step is to enhance your AI solution’s performance, optimize API workloads, and improve production observability—laying the groundwork for scalable, efficient, and reliable operations. These capabilities help keep AI systems cost‑effective and reliable as usage grows. Key Resources See curated, step-by-step guidance to help you build, publish, or sell your app or agent (no matter where you start) in App Advisor Quick-Start Development Toolkit can connect you with code templates for AI solution patterns Microsoft AI Envisioning Day Events How to build and publish AI apps and agents for Microsoft Marketplace Get over $126K USD in benefits and technical consultations to help you replicate and publish your app with ISV SuccessIntegrate Marketplace commerce signals to enforce entitlements in AI apps
How fulfillment and entitlement models differ by Microsoft Marketplace offer type AI apps and agents increasingly operate with runtime autonomy, dynamic capability exposure, and on‑demand access to tools and resources. That flexibility creates a new challenge for software companies: enforcing commercial entitlements (what a customer is allowed to access or use at runtime) correctly after a customer purchase through Microsoft Marketplace. Marketplace is the system of record for commercial truth, but enforcement always lives in your application, agent, or deployed resources. This post explains how Marketplace fulfillment and entitlement models differ by offer type—and what that means when you’re designing AI apps and agents that must respond correctly to subscription state, plan changes, and cancellations. You can always get a curated step-by-step guidance through building, publishing and selling apps for Marketplace through App Advisor. This post is part of a series on building and publishing well-architected AI apps and agents in Microsoft Marketplace. The series focuses on AI apps and agents that are architected, hosted, and operated on Azure, with guidance aligned to building and selling solutions through Microsoft Marketplace. Why AI apps and agents must integrate with Marketplace commerce signals Microsoft Marketplace is the commercial system of record for: Tracking purchase and subscription state Managing plan selection and plan changes Signaling cancellation and suspension AI apps and agents, by contrast, operate in environments where decisions are made continuously at runtime. They expose capabilities dynamically, invoke tools conditionally, and often operate without a human in the loop. That mismatch makes static enforcement insufficient, including: UI‑only checks Configuration‑time gating Prompt‑based constraints Marketplace communicates commercial truth, but it does not enforce value. That responsibility always belongs to the publisher’s application, agent, or deployed resources. Correct integration starts with understanding what Marketplace provides—and what your software must implement. What Marketplace provides—and what publishers must implement Before diving into APIs or offer types, it’s important to separate responsibilities clearly. Marketplace provides authoritative commercial signals, including: Subscription existence and current state Plan and entitlement context Licensing or usage boundaries associated with the offer Marketplace does not: Enforce your business logic Control runtime behavior Automatically limit feature or resource access Publishers are responsible for translating Marketplace signals into: Application behavior Agent capabilities Resource access boundaries That enforcement must be deterministic, auditable, and aligned with what the customer actually purchased. How those signals surface—through APIs, deployment constructs, licensing context, or metering—depends entirely on the fulfillment and entitlement model of the offer. How fulfillment and entitlement models differ by offer type Microsoft Marketplace supports multiple offer and fulfillment models, including: SaaS subscriptions Azure Managed Applications Container offers Virtual machine offers Other specialized Marketplace offer types Each model determines: How a customer receives value Where commercial signals appear Which integration mechanisms apply Where entitlement enforcement must occur Some offers rely on Marketplace APIs. Others rely on deployment‑time enforcement, resource scoping, or usage constraints. There is no single integration pattern that applies to every offer. Understanding this distinction is essential before designing entitlement enforcement for AI apps and agents. Marketplace integration responsibilities by offer type This section is the technical anchor of the post. Marketplace APIs are not universal; they apply differently depending on the offer model. SaaS offers SaaS offers integrate directly with Microsoft Marketplace through the SaaS Fulfillment APIs. These APIs are used to: Activate subscriptions Track plan changes Enforce suspension and cancellation In this model, Marketplace communicates subscription lifecycle events, but it does not enforce access. The publisher must: Map Marketplace subscriptions to internal tenants Maintain a durable subscription record Enforce entitlements at runtime For AI apps and agents, that enforcement typically happens in orchestration logic or tool‑invocation boundaries—not in the UI or prompts. SaaS Fulfillment APIs are the primary mechanism for receiving commercial truth, but the application remains responsible for acting on it. Container offers Container offers deliver value as container images and associated artifacts, such as Helm charts. In this model, the publisher is shipping a deployable artifact—not an application endpoint or API managed by Marketplace. Marketplace provides: Entitlement to deploy the container image Optional usage‑based billing and metering Ability to deploy to an existing AKS cluster or to a publisher configure one Enforcement occurs at: Deployment time, by controlling access to images Runtime usage, through configuration and limits Metered dimensions, when usage‑based billing applies For AI workloads packaged as containers, entitlement enforcement is typically embedded in the runtime configuration, resource limits, or metering logic—not in Marketplace APIs. Virtual machine offers Virtual machine offers are fulfilled through VM image deployment. In this model: Fulfillment is based on VM deployment Licensing and usage are enforced through the VM lifecycle Subscription state is less event‑driven but still contractually binding While there is no SaaS‑style fulfillment callback, publishers must still ensure that deployed workloads align with the purchased offer. For AI solutions delivered via VM images, enforcement is tied to licensing, configuration, and operational controls inside the VM. Azure Managed Applications For Azure Managed Applications, fulfillment is enforced through the Azure Resource Manager (ARM) deployment lifecycle. In this model: A Marketplace purchase establishes deployment rights Resources are deployed into a managed resource group Operational boundaries are defined by ARM and Azure role assignments Publishers enforce value through: Deployment behavior Resource configuration Lifecycle management and updates For AI solutions delivered as managed applications, entitlement enforcement is tied to what is deployed and how it is operated—not to an external subscription API. Marketplace establishes the contract, and Azure enforces access through infrastructure boundaries. Other offer types Other Marketplace offer types follow similar patterns, with varying degrees of API involvement and deployment‑time enforcement. The key principle holds: Marketplace establishes commercial rights, but enforcement is always implemented by the publisher, using the mechanisms appropriate to the offer model. Designing entitlement enforcement into AI apps and agents Entitlements must be enforced outside the model. Large language models should never be responsible for deciding what a customer is allowed to do. Effective enforcement belongs in: The interaction layer The orchestration layer Tool invocation boundaries Avoid: UI‑only enforcement Prompt‑based entitlement logic Soft limits without auditability AI agents should request capabilities from deterministic services that already understand subscription state and plan entitlements. This ensures enforcement is consistent, testable, and resilient. Handling plan changes, upgrades, and feature tiers Plan changes are common in Microsoft Marketplace. AI capability must align continuously with: The active subscription tier Purchased dimensions or limits Common examples include: Agent autonomy limits Tool or connector access Rate limits Data scope Feature gating must be deterministic and testable. When a plan changes, your application or agent should respond predictably—without manual intervention or redeployment. Failure, retry, and reconciliation patterns Marketplace events are not guaranteed to be: Ordered Delivered once Immediately available AI apps must handle: Duplicate events Missed callbacks Temporary Marketplace or network failures Reconciliation processes protect customers, publishers, and Marketplace trust. Periodic verification of subscription state ensures that runtime enforcement remains aligned with commercial reality. How Marketplace API integration affects readiness and review Marketplace reviewers look for: Clear enforcement of subscription state Clean suspension and revocation paths Strong integration leads to: Faster certification Fewer conditional approvals Lower support burden after launch Correct enforcement is not just a technical requirement—it’s a Marketplace readiness signal. What’s next in the journey Once entitlement enforcement is solid, the next layer of operational maturity includes: Usage‑based billing and metering architecture Performance, caching, and cost optimization Observability and operational health for AI apps and agents Key resources See curated, step-by-step guidance to help you build, publish, or sell your app or agent (no matter where you start) in App Advisor Quick-Start Development Toolkit can connect you with code templates for AI solution patterns Microsoft AI Envisioning Day Events How to build and publish AI apps and agents for Microsoft Marketplace Get over $126K USD in benefits and technical consultations to help you replicate and publish your app with ISV SuccessMicrosoft Marketplace 101: Insights from high performing software development company sellers
Microsoft Marketplace is probably the one topic that can give 'AI' a run for its money in terms of the number of mentions on LinkedIn, on cloud hyperscaler blogs, and in Partner Ecosystem presentations. But ask the average SaaS seller what a marketplace is, and you’ll probably get a different answer every time. That’s because marketplaces have become more than just a listing catalog, it’s now a pervasive commerce platform across the entire B2B Software purchase process. Jay McBain @ Omdia described Cloud Marketplaces as the "epicenter of partnerships, co-selling and co-innovation” and we see that play out at Microsoft. The combination of Microsoft's co-sell model and Microsoft Marketplace has created the platform for modern procurement and modern partnerships. Today, Microsoft Marketplace: Impacts all personas and incentives – from customers commercial incentives, to software company program sale incentives, channel partner benefits, and hyperscaler seller compensation models Enhances B2B purchase processes for customers – Streamlining supplier onboarding, to internal FinOps, to governance and guardrails on purchasing Brings agility to the sales process for software companies and channel partners – from pricing and quoting, budget allocation, billing & payments, right through to co-selling and go-to-market. With this level of impact, it’s not surprising that Microsoft Marketplace represents a significant growth opportunity for software companies. Customers are increasingly transacting through Marketplace as they align Azure commitments with third-party software purchases and adopt a more “marketplace-first” procurement approach. Research shows 69% of partners report larger deals and 75% close deals faster (Omdia), reinforcing the role of Marketplace as a strategic channel for enterprise software procurement. So, if you are a seller at a Microsoft SaaS software company and you want to take advantage of this opportunity, here are my five top learnings for high performance software sellers! This article assumes you are running your SaaS software platform on Microsoft Azure and you are already transactable in Marketplace. If you aren't, there are plenty of great resources for software companies to help get you there, and I have summarized them here: New Software Company Partner Guide. LEARNING 1 - Understand the customer benefits of Microsoft Marketplace and weave it into your customer proposal: This is about understanding the bigger picture of Marketplace for Microsoft customers, as the benefits go way beyond an individual transaction. The average enterprise is managing over 600 applications (Source - Zylo) and >60% of these applications being purchased outside of IT. Marketplace is a great way for customers to scale and bring efficiency across their B2B Software estate, giving them: Rapid access (find, try, buy) to software and AI innovation they need to run their business, Governance and guardrails for each purchase – so you are never compromising control and compliance. Streamlined procurement – onboarding suppliers in minutes using their Microsoft Agreement, invoicing and payment terms, Improved cloud economics – aligning the cloud consumption with your software company spend can unlock additional P&L impacting benefits, If you need to get up to speed on these aspects, check out: Microsoft Marketplace 101 - Top Customer Questions. LEARNING 2 - Understand how Microsoft partners can help you scale and close customer opportunities: Microsoft has always been a partner led organization. Today we have 500,000 partners globally ranging from a small start-up in a garage, to the largest Global Systems Integrator. These partners play different roles in our customers helping them transform and compete in the AI era through Microsoft Cloud & AI technologies. The great news for you is that we have empowered Microsoft channel partners and sales partners to sell Marketplace solutions. So, think about how you can use channel partners to (i). expand your reach, (ii). drive new opportunities or (iii). accelerate deal closure. We have a range of different models to support your channel led motions in our customers, including: Multi-party private offers (MPO) - Partner led sales agents for individual transactions. Resale enabled offers (REO) - Nominated and enabled partner representative by geo. Cloud solution provider (CSP) resellers - to scale into SMB/Corporate Accounts via a managed service provider For each opportunity, understand who the incumbent Microsoft partner is, and how you can use these mechanisms to accelerate your deal. Or better still, if you are looking to explore a more proactive partnership, check out the 1000s of Partners that are building Marketplace practices to support customers and software companies. Examples include Bytes, Softcat, CDW, Trustmarque, Crayon, Computacenter etc. LEARNING 3 - Accelerate your deal closure by including Microsoft programs and incentives into your customer proposal: Here are the most commonly used accelerators used by software company sellers to close deals: If you are marketplace transactable: Marketplace Rewards - Azure Sponsorship Credits - A performance related benefit that provides up to $400k in Azure Sponsorship Credits. These credits can be used as a deal sweetener with your Marketplace transaction and passed on to the customer for consumption. Up to 40% of transactions involve these credits today. If you are IP co-sell ready: Azure Benefit Eligible - This enables customers to decrement their Microsoft Azure Consumption Commitments (MACC) with eligible Marketplace purchases. By aligning their cloud consumption with their software company spend, it can unlock additional P&L impacting benefits. More than 85% of MACC customers buy via Marketplace. Microsoft IP co-sell incentive - This enables Microsoft sellers to get paid on the license value sold via Microsoft Marketplace. It also allows eligible Marketplace transactions to contribute to retiring Microsoft seller quota, helping accelerate deal alignment between partners and Microsoft field teams. If you have a Certified Software Designation (CSD): Marketplace Rewards - Azure Sponsorship Credits - If you come CSD Certified, Microsoft extends this benefit to $1M. These credits can be used as a deal sweetener with your Marketplace transaction and passed on to the customer for consumption. Customer Migrate & Modernize Incentive - This partner incentive is used to drive migrations to Microsoft Azure. Cash incentives vary based project size, but Microsoft will pay up to $200k per opportunity for NEW customer migrations to Microsoft Azure. High-performing software companies and sellers will combine these incentives into their proposals to help drive customer acquisition success. LEARNING 4 - Know your Microsoft customer Three things I urge every software company Seller to do as part of their Marketplace and co-sell conversations: Know your customer 1 - Understand the customer's Marketplace Propensity Score to help prioritize your opportunities Marketplace Propensity Scoring (combined with your co-Sell conversations) has proven a powerful tool for prioritizing pipeline and accelerating sales cycles. Offered as a Marketplace Rewards benefit, propensity scoring provides you with a score that ranks your pipeline prospects by their likelihood (0 to 100) to transact through Marketplace. The score is based on a number of factors including their commercials, existing spend and transaction volumes, relationship metrics etc. Access the benefit at: Microsoft Marketplace Rewards Know your customer 2 - Enable more tailored offers for customers by updating your MEDDIC, MEDDPICC or BANT qualification questions with these Marketplace qualifiers: Are they a Microsoft customer? This means they have agreed Microsoft terms and conditions to enable Marketplace transactions. Are they a Managed Microsoft Customer? This opens up the possibility of selling with Microsoft. What Microsoft segment/industry are they in? This opens up sales play alignment, industry go-to-market etc. How do they buy Microsoft Azure today? This helps navigate potential commercials, incentives and programs, purchase routes and the role of channel partners. Does the customer have a Microsoft Azure Consumption Commitment (MACC)? This could unlock the MACC benefit of Azure Benefit Eligible which allows customers to decrement marketplace purchases. What is the status of their Microsoft Azure Consumption Commitment (MACC)? Are they ahead or behind of their consumption commitment? Is it coming up for renewal? This is all about getting access to planned Azure budgets at the right time. Is there an incumbent Microsoft partner in the customer and what role do they play? It is forecasted that 60% of ALL marketplace sales will involve a channel partner, so get them involved early in the process. Know Your Customer 3 - Use the Partner Center referral process to engage incentivized Microsoft sellers and gain customer intelligence: Submitting your referrals via Partner Center will enable you to engage incentivized Microsoft sellers directly. For most Microsoft sellers, Microsoft Marketplace and co-sell deals are critical for how they will make their Azure quota. Help could include: Navigate and increase your visibility with the customer's buyers Gain insights on the customer's Azure commitments, Understand the partner landscape in the customer Potentially find ways to combine sales motions to drive bigger/better outcomes for all. Build this discipline with every opportunity is a key characteristic of a high-performance software company seller. LEARNING 5 - Celebrate and amplify Microsoft co-sell/Marketplace success The best Microsoft Marketplace and co-sell partners treat Microsoft as a customer. They market to the Microsoft sales and go-to-market teams the success they are driving, which in turn is driving further engagement and activity. Work with your aligned Microsoft Partner Development Manager to create a regular drumbeat of communication or use your Marketplace Rewards GTM benefits to amplify your success with the Microsoft sales teams. Need more help? Speak to your Partner Development Manager or aligned engagement manager Check out App Advisor for a guided experience on the journey for software development companies. Let me know your feedback or if you have any additional recommendations. Thanks Lee Corbett - EMEA ISV Recruit & Grow LeadDesign tenant linking to scale selling on Microsoft Marketplace
Designing tenant linking and Open Authorization (OAuth) directly shapes how customers onboard, grant trust, and operate your AI app or agent through Microsoft Marketplace. This post explains how to design scalable, review‑ready identity patterns that support secure activation, clear authorization boundaries, and enterprise trust from day one. Guidance for multi‑tenant AI apps Identity decisions are rarely visible in architecture diagrams, but they are immediately visible to customers. In Microsoft Marketplace, tenant linking and OAuth consent are not background implementation details. They shape activation, onboarding, certification, and long‑term trust with enterprise buyers. When identity decisions are made late, the impact is predictable. Onboarding breaks. Permissions feel misaligned. Reviews stall. Customers hesitate. When identity is designed intentionally from the start, Marketplace experiences feel coherent, secure, and enterprise‑ready. This post focuses on how software development companies (like ISVs) can design tenant linking and consent patterns that scale across customers, offer types, and Marketplace review—without rework later. You can always get curated step-by-step guidance through building, publishing and selling apps for Marketplace through App Advisor. This post is part of a series that focuses on AI apps and agents that are architected, hosted, and operated on Azure, with guidance aligned to building and selling solutions through Microsoft Marketplace. Why identity across tenants is a first‑class design decision Designing identity is not just about authentication. It is about how trust is established between your solution and a customer tenant, and how that trust evolves over time. When identity decisions are deferred, failure modes surface quickly: Activation flows that cannot complete cleanly Consent requests that do not match declared functionality Over‑privileged apps that fail security review Customers who cannot confidently revoke access These are not edge cases. They are some of the most common reasons Marketplace onboarding slows or certifications are delayed. A good identity and access management design ensures that trust, consent, provisioning, and operation follow a predictable and reviewable path—one that customers understand and administrators can approve. Marketplace tenant linking requirements A key mental model simplifies everything that follows: separate trust establishment from authorization. Tenant linking and OAuth consent solve different problems. Tenant linking establishes trust between tenants OAuth consent grants permission within that trust Tenant linking answers: Which customer tenant does this solution trust? OAuth consent answers: What is this solution allowed to do once trusted? AI solutions published in Microsoft Marketplace should enforce this separation intentionally. Trust must be established before meaningful permissions are granted, and permission scope must align to declared functionality. Making this distinction explicit early prevents architectural shortcuts that later block certification. Throughout the rest of this post, tenant linking refers to trust establishment, not permission scope. Microsoft Entra ID as the identity foundation Microsoft Entra ID provides the primitives for identity-based access control, but the concepts only become useful when translated into publisher decisions. Each core concept maps to a choice you make early: Home tenant vs resource tenant Determines where operational control lives and how cross‑tenant trust is anchored. App registrations Define the maximum permission boundary your solution can ever request. Service principals Determine how your app appears, is governed, and is managed inside customer tenants. Managed identities Reduce long‑term credential risk and operational overhead. Understanding these decisions early prevents redesigning consent flows, re‑certifying offers, or re‑provisioning customers later. Marketplace policies reinforce this by allowing only limited consent during activation, with broader permissions granted incrementally after onboarding. Importantly, activation consent is not operational consent. Activation establishes the commercial and identity relationship. Operational permissions come later, when customers understand what your solution will actually do. OAuth consent patterns for multi‑tenant AI apps OAuth consent is not an implementation detail in Marketplace. It directly determines whether your AI app can be certified, deployed smoothly, and governed by enterprise customers. Common consent patterns map closely to AI behavior: User consent Supports read‑only or user‑initiated interactions with no autonomous actions. Admin consent Enables agents, background jobs, cross‑user access, and cross‑resource operations. Pre‑authorized consent Enables predictable, enterprise‑grade onboarding with known and approved scopes. While some AI experiences begin with user‑driven interactions, most AI solutions in Marketplace ultimately require admin consent. They operate asynchronously, act across resources, or persist beyond a single user session. Aligning expectations early avoids friction during review and deployment. Designing consent flows customers trust Consent dialogs are part of your product experience. They are not just Microsoft‑provided UI. Marketplace reviewers evaluate whether requested permissions are proportional to declared functionality. Over‑scoped consent remains one of the most common causes of delayed or failed certification. Strong consent design: Requests only what is necessary for declared behavior Explains why permissions are needed in plain language Aligns timing with customer understanding Poor explanations increase admin rejection rates, even when permissions are technically valid. Clear consent copy builds trust and accelerates approvals. Tenant linking across offer types Identity design must align with offer type; a helpful framing is ownership: SaaS offers The publisher owns identity orchestration and tenant linking. Microsoft Marketplace reviewers expect this alignment, and mismatches surface quickly during certification. Containers and virtual machines The customer owns runtime identity; the publisher integrates with it. Managed applications Responsibility is shared, but the publisher defines the trust boundary. Each model carries different expectations for control, consent, and revocation. Designing tenant linking that matches the offer type reduces customer confusion. When consent actually happens in Marketplace lifecycle Many identity issues stem from unclear timing. A simple lifecycle helps anchor expectations: Buy – The customer purchases the offer Activate – Tenant trust is established Consent – Limited activation consent is granted Provision – Resources and configurations are created Operate – Incremental operational consent may be requested Revoke – Access and trust can be cleanly removed Making this sequence explicit in your design—and in your documentation—dramatically reduces confusion for customers and reviewers alike. How tenant linking shapes Marketplace readiness Identity tends to leave a lasting impression as it is one of the first architectural design choices encountered by customers. Strong tenant linking and consent design leads to: Faster certification (applies to SaaS offer only) Fewer conditional approvals Lower onboarding drop‑off Easier enterprise security reviews These outcomes are not accidental. They reflect intentional design choices made early. What’s next in the journey Tenant identity sets the foundation, but it is only one part of Marketplace readiness. In upcoming guidance, we’ll connect identity decisions to commerce, SaaS Fulfillment APIs, and operational lifecycle management—so buy, activate, provision, operate, and revoke work together as a single, coherent system. Key Resources See curated, step-by-step guidance to help you build, publish, or sell your app or agent (no matter where you start) in App Advisor Quick-Start Development Toolkit can connect you with code templates for AI solution patterns Microsoft AI Envisioning Day Events How to build and publish AI apps and agents for Microsoft Marketplace Get over $126K USD in benefits and technical consultations to help you replicate and publish your app with ISV Success
