Partner Blog | What’s new for Microsoft partners: July 2026 edition
July 7, 2026[Launched] Generally Available: Support 5x churn in Azure Site Recovery
July 7, 2026
In this issue:
Ace Aviator of the Month
July 2026’s Ace Aviator: Bill Chesnut
What’s your role and title? What are your responsibilities?
Cloud Platform and API Evangelist for SixPivot based in Melbourne, Australia – Everything Integration.
Can you give us some insights into your day-to-day activities?
My day-to-day activities are very much the same every day: some days working on Azure Landing Zones for Integration, developing Logic Apps and Function Apps, and supporting existing Azure Integration and BizTalk.
What motivates and inspires you to be an active member of the Aviators/Microsoft community?
I really enjoy helping others learn about technology and solve their business problems. At the start of my BizTalk journey in the early 2000s, I also did a lot of BizTalk training across Australia and NZ for Microsoft. When Azure Integration came around, I also created a Cloud Integration Training course that I delivered for SixPivot.
Looking back, what advice do you wish you had been given earlier?
Always keep your mind open to new things, and never stop learning.
What has helped you grow professionally?
Staying involved in the community has really helped me grow professionally. You are always encountering new things and meeting interesting people.
If you had a magic wand that could create a feature in Logic Apps, what would it be?
The one thing I use a lot in my development is Azure App Configuration. It would be nice to be able to create parameters and link them inside the logic app to Azure App Configuration, instead of in the environment variables.
News from our product group
On the road to .NET 10 Support: Logic Apps Migration from In-Proc to Out-of-Proc hosting model
Microsoft is migrating Logic Apps Standard from the in-proc to the Azure Functions out-of-proc hosting model as a step toward .NET 10 support. For most customers the change is automatic with no action required, but apps using the NuGet-based deployment model need manual preparation. Teams must preserve the LOGICAPP_INPROC_REDIRECT=1 app setting in their deployment pipelines to prevent premature auto-migration until the app is ready. Key points: the rollout begins around July 30, 2026; automatic migration happens on app restart for apps without the redirect flag; NuGet-based apps must download the latest Functions Core Tools, update project configuration to out-of-proc, and validate locally before removing the redirect setting.
Dynamic Connection Properties in Azure Logic Apps Standard
Logic Apps Standard now supports dynamic connection names for built-in (service provider) connectors, solving the problem where a single workflow shared by multiple teams previously required duplicated workflows or hardcoded connections. Instead of hardcoding a connection name, you supply any workflow expression—trigger inputs, action outputs, parameters, or conditional logic—in the connectionName field, and the runtime resolves it against connections.json at execution time. Key points: define multiple connections (one per team/environment/tenant) in connections.json; resolve names via expressions like @triggerBody(), headers, or if() conditionals; works today only via Code View with no designer support; illustrated with a step-by-step dynamic SFTP connection example using app settings for credentials.
Productize, observe, version, and automate MCP servers in Azure API Management
As organizations move from AI-assisted apps to agentic workflows, MCP servers become a critical integration layer between agents, tools, APIs, and enterprise systems. Azure API Management already brings MCP servers under governance, but scaling adoption demands deeper management. This post announces new generally available capabilities that make MCP servers first-class managed resources. Key points: add MCP servers to Products to package and govern capabilities for specific consumers; MCP tool observability to trace tool usage, logs, errors, and payload context; MCP server versioning to run multiple versions side by side and manage change safely; and Management API plus Bicep support to automate MCP configuration in CI/CD—applying familiar API governance patterns (products, subscriptions) to MCP.
Automatically Route Azure Service Health Alerts to the Right Service Owners Using Agentic Logic Apps
Azure Service Health alerts often land in a shared mailbox, requiring manual triage across platform, database, application, security, and AI teams. This post shows how to automate routing by combining Service Health, Azure Monitor Action Groups, and an Autonomous Agent Logic App. The agent matches impacted services to an ownership map and notifies the correct stakeholders, with a fallback for unmapped services. It covers configuring Service Health alerts, triggering Logic Apps from Action Groups, maintaining the service-to-owner repository, and designing agentic routing to reduce operational overhead and response delays.
News from our community
DLQ Replay Is Not a Recovery Strategy
Post by Al Ghoniem, MBA
This article explains why dead-letter queue (DLQ) replay is not a true recovery strategy in distributed systems. A DLQ contains failed messages but cannot decide if replay is business-safe, especially when downstream operations may have already committed. The author outlines risks like duplicate postings and incorrect outcomes, and proposes a controlled replay workflow with idempotency keys, reconciliation steps, failure classification, RBAC, and detailed observability. Practical guidance includes preserving original command context, checking an idempotency store before action, and exposing replay through API Management for governance. A simple decision tree and logging model support auditability and operational safety.
Naming conventions for Azure Integration Services: How I structure a Hybrid Integration Platform in Microsoft Azure
Post by Şahin Özdemir
This practical guide sets out a consistent naming convention for Azure Integration Services within a hybrid integration platform. It explains why disciplined naming improves readability, maintainability, RBAC clarity, and automation for IaC and DevOps. The core formula—resource-org-workload-integration-context-environment—is applied across three architectural tiers (core, shared, integration), with detailed examples for resource groups, virtual networks, subnets, NSGs, Function Apps, Logic Apps Standard, and API connections. The article covers lowercase and hyphen rules, storage account exceptions, and workflow naming (receiver, processor, sender, helper, agent loops). It also touches on claim-check patterns, observability artifacts, and practical constraints like Key Vault name limits.
Building Azure Logic Apps Agent Tools: Connectors and MCP
Post by Steef-Jan Wiggers
Part 4 of the Logic Apps Agent Loop series dives into tools—the mechanisms that let an agent interact with the world. It describes three layers: built-in and managed connectors for common integrations, custom connectors wrapping internal REST APIs for reuse across a tenant, and MCP servers that invert the model by exposing a Logic Apps workflow as a tool provider callable by external agents. The post explains agent parameters, naming and descriptions, and shares preview limitations with API Center’s MCP wizard and Azure AI Foundry’s OpenAPI tool networking. It offers Azure API Management as a practical workaround and guidance on choosing the right layer.
Creating Azure Sandbox Chatbot with Azure Logic Apps
Post by Adam Marczak
This article outlines a practical Teams-based chatbot pattern for creating ephemeral Azure sandboxes using Azure Logic Apps. A Logic Apps workflow acts as the chatbot, granting users Owner permissions to temporary resource groups that auto-delete after 12 hours, with optional quotas and policies to prevent abuse. It explains single-tenant and multi-tenant setups, Entra objects (service principal, service user), the use of adaptive cards, and governance through tags, Azure Policies, and resource providers. Guidance includes enterprise pipelines (ADO/GitHub) for provisioning, sample workflow screenshots, and GitHub-hosted JSON for the Logic App and adaptive card.
Mastering Enterprise Integration Patterns with Logic Apps
Post by Parth T.
This piece introduces how Enterprise Integration Patterns (EIPs) pair with Azure Logic Apps to build scalable, maintainable cloud-native architectures. It explains the role of Logic Apps as an orchestration platform across APIs and events, and highlights benefits such as reusability, observability, and reduced complexity. The article surveys how messaging and workflow patterns map to Logic Apps constructs, when to apply them in distributed systems, and why integration architecture is increasingly strategic. It invites practitioners to consider their most-used EIPs and positions Logic Apps as a pragmatic way to implement patterns without heavy custom code.
Your Retry Policy Is Not an Idempotency Strategy
Post by Al Ghoniem, MBA
Al Ghoniem clarifies why retries are not a safety mechanism and must be paired with idempotency to avoid duplicate business outcomes. The article distinguishes transport messages, business commands, and outcomes, and outlines practical idempotency keys (client-generated, natural, composite). It places responsibilities across Azure services—APIM as gatekeeper, Service Bus for durability, Functions as command handlers—and insists on a durable store with atomic handling and clear conflict behavior. Guidance covers DLQ replay, Logic App resubmission, payload hashing, and observability in Application Insights. The takeaway: design for safe repetition, not just repeated execution.
When Logic Apps Beat Custom Code (And When They Don’t)
Post by Parth T.
Parth Talaviya explains when Azure Logic Apps deliver the most value and when custom code is the better fit. Logic Apps excel in rapid orchestration, reduced operational overhead, cost-effective common workflows, and a rich connector ecosystem. Custom code is preferred for complex domain logic, high-performance processing, advanced security/compliance needs, and reduced platform dependency. The piece frames the decision as trade-offs, not rivalry, and encourages combining both approaches—using Logic Apps for orchestration and SaaS integrations, and code for core business services. Architecture should track complexity, team capabilities, and long-term maintainability.
Boosting Retention: Managing Execution History in Logic Apps Standard
Post by Anitha Eswaran
This guide explains how to extend or adjust the default 90‑day execution history retention in Logic Apps Standard. It details portal-based configuration and project settings, including Workflows.RuntimeConfiguration.RetentionInDays and Runtime.FlowMaintenanceJob.RetentionCooldownInterval. The article clarifies why some historical runs may persist up to 97 days due to the cleanup cadence, and how retention is calculated based on the run’s start time. It shows how to scope retention globally or per workflow (Workflows..RuntimeConfiguration.RetentionInDays), with practical steps, screenshots, and recommended ranges (7–365 days) to balance troubleshooting visibility and storage considerations.
Choosing the Right AI Agent: Logic Apps Agent Loop vs Microsoft Foundry vs Copilot Studio — Real-Life Scenarios for Architects
Post by Kunal Saha
Kunal Saha compares three Azure agent platforms from a Logic Apps practitioner’s viewpoint. Logic Apps Agent Loop suits event-driven, integration-heavy automation that benefits from adaptive reasoning across connectors. Microsoft Foundry is positioned for multi-agent systems, evaluation rigor, and deep model flexibility beyond OpenAI, making it fit when AI reasoning quality becomes the main engineering challenge. Copilot Studio specializes in conversational Teams experiences, with native publishing and Power Platform connectors. The article offers plain decision rules—event- vs conversation-driven, integration vs AI-centric—and maps five enterprise scenarios to the right choice, urging architects to mix platforms based on problem fit.
Azure Integration Roadmap Sessions
Post by Michael Stephenson
Michael Stephenson previews Microsoft’s Azure Integration roadmap sessions at the Integrate 2026 event. He links teaser videos covering BizTalk migration guidance, API Management roadmap, Logic Apps roadmap, Service Bus, Event Grid, and Event Hub. The piece provides the event page, YouTube playlist, and direct video links per topic. It positions these sessions as high‑value for architects and integration teams planning modernization and migration strategies, and suggests the content will outline direction and capabilities across core Azure Integration Services—useful for those moving BizTalk workloads or strengthening governance around APIs and messaging.
Logic Apps Automation release, what is it, and how it works?
Post by Adam Marczak
Adam Marczak explains the Logic Apps Automation preview: a new AI‑first SKU with a redesigned portal (auto.azure.com), updated hierarchy (Projects → Applications → Workflows), sandboxes, and 0‑to‑N scaling. He contrasts Automation with Standard and Consumption across runtime isolation, scale‑to‑zero, networking, and billing. Noted gaps include CICD export, whole‑project code export, and VNET availability in preview. Practical guidance includes portal screenshots, run history differences (real‑time in Automation), and decision tables suggesting when Automation, Standard, or Consumption fits best. Related reading links to Microsoft docs and Logic Apps Labs content.
Logic Apps and Event Grid: Event-Driven Architecture in Azure
Post by Marcel Broschk
This article explains how Azure Event Grid and Azure Logic Apps combine to enable event-driven architecture at scale. Event Grid provides serverless, high-throughput event routing with filtering, retries, and dead-lettering, while Logic Apps orchestrate multi-step workflows using hundreds of connectors. The piece outlines common patterns, such as reacting to blob uploads to trigger AI extraction, storage, and approvals, and discusses key design considerations like idempotency, error handling, and security with managed identities and private endpoints. It also touches on cost and performance trade-offs and highlights practical use cases across operations, business automation, and hybrid integration.
Introduction to Azure Logic Apps Automation | Getting Started with Azure Logic Apps Automation
Video by Srikanth Gunnala
This introductory video walks through Azure Logic Apps Automation and how to get hands-on quickly. It explains the service’s goals, shows how to start building workflows, and demonstrates connecting triggers and actions to automate tasks with minimal setup. Viewers see how to design a simple end-to-end process, integrate with common Microsoft 365 services, and apply AI-assisted authoring to accelerate workflow creation. The session emphasizes practical steps—where to begin, how to wire inputs and outputs, and what to consider for moving from a demo to production-ready automation.
How To: Call an Azure AI Foundry Agent from a Logic App
Post by Craig Chiffers
Craig Chiffers presents a step-by-step guide for wiring Microsoft Teams to an Azure AI Foundry agent using Azure Logic Apps—without custom connectors or Azure Functions. The walkthrough covers creating a Teams channel trigger, composing and cleaning message content, posting an HTTP request to the agent endpoint, parsing the JSON response, and replying in-thread to Teams. It includes tips for authentication (API key versus Managed Identity), error handling, and formatting replies, plus suggestions for enhancements like conversation history, loop prevention, and reusable patterns. It’s a practical blueprint for bringing agents into everyday workflows.
Healthcare Integration Teams Are About to Get a Lot More Interesting
Post by Gautam Gyanendra
Gautam Gyanendra outlines how healthcare integration teams can evolve by layering agentic workflows on top of deterministic systems. He distinguishes predictable, auditable processes handled by tools like Azure Logic Apps, Service Bus, and API Management from AI-driven reasoning that adapts to context. The article proposes a hybrid architecture where agents summarize charts, detect gaps, and escalate uncertainty to humans, while deterministic layers execute reliably with governance and audit trails. It maps Microsoft services to each layer and explains why combining them will shape healthcare operations over the next three to five years.