logic apps
377 TopicsWhat's new in Azure Logic Apps at Microsoft Ignite 2026
Organizations are exploring how AI can make their business processes more intelligent, but many still rely on legacy integration infrastructure that makes innovation difficult. Bringing AI into enterprise operations requires more than connecting a model or deploying an agent. It requires reliable access to business systems and data, orchestration across applications and people, and the ability to act securely and predictably. Azure Logic Apps brings enterprise connectivity and orchestration together, helping organizations connect applications and data, automate processes across systems, and bring AI into business workflows with the reliability and control their operations require. At Microsoft Ignite 2026, we're advancing Azure Logic Apps across three priorities: modernize legacy integrations, build automation faster, and bring AI into business processes. Modernize the integrations your business depends on Legacy integration infrastructure continues to support critical business processes, but it can make adopting AI more complex. Organizations need to modernize without disrupting the systems they depend on. At Ignite, we're introducing new capabilities that help organizations modernize legacy integrations, connect more enterprise systems, and manage integrations across cloud and hybrid environments. Connect more enterprise systems: The HL7 connector is now generally available, while new MLLP and MSMQ connectors in public preview extend support for healthcare messaging and legacy applications. Data Mapper enhancements simplify transformations across applications and message formats, reducing custom integration work. Modernize across cloud and hybrid environments: Hybrid Logic Apps continues to expand with support for additional Kubernetes environments, including RKE2 and Red Hat OpenShift, alongside DevOps deployment capabilities and Integration Account support in semi-connected environments. Organizations gain greater flexibility to modernize integrations where their systems and data reside. Improve operational visibility: A new unified dashboard, available in public preview for individual Logic Apps, helps teams monitor workflow execution and troubleshoot integrations through a consolidated experience. These capabilities help organizations modernize at their own pace while maintaining the connectivity and reliability their businesses depend on. The Kentucky Cabinet for Health and Family Services (CHFS) shows what this can look like in practice. CHFS modernized its legacy on-premises BizTalk infrastructure to Azure Integration Services, including Azure Logic Apps, Azure API Management, and Azure Functions. The modernization improved scalability, reliability, and operational efficiency. Today, its integration environment processes approximately 7 million transactions daily, supports more than 1,800 APIs, and connects over 60 partners helping CHFS focus more on delivering essential public services and less on maintaining legacy infrastructure. Read the customer story here. Build automation faster Developers need the flexibility to build integrations and automations using familiar tools without maintaining custom integration infrastructure. At Ignite, we're expanding development options across managed connectivity and reusable automation experiences. Bring managed connectivity into application code: Azure Connector Namespace gives developers access to enterprise systems through .NET, Node.js, and Python SDKs or HTTP APIs without building and maintaining custom integration code. It also supports exposing connectors as MCP tools for AI agents. Explore Connector Namespace. Start faster and reuse proven patterns: Logic Apps Automation (preview) introduces a refreshed workflow designer and ready-to-use templates for integration, Azure operations, and AI-powered automation. Teams can also turn successful workflow runs into reusable templates and share them across projects and organizations. Together, these capabilities help teams reduce development overhead, accelerate delivery, and build integrations and automations using the tools and approaches that work best for them. Make business processes intelligent with AI As organizations introduce AI into business processes, they need to combine predictable workflows with AI-powered decisions, agent reasoning, and human involvement. At Ignite, we're expanding Logic Apps Automation (preview) to help organizations bring these capabilities together while maintaining enterprise reliability and control. Orchestrate workflows and agents: Logic Apps Automation brings workflows, enterprise systems, agents, and people together within business processes. Through integration with Microsoft Foundry, organizations can bring agents built in Foundry into workflows orchestrated by Logic Apps, connecting AI-powered reasoning and actions to enterprise systems and human approvals. Apply AI where an agent isn't required: Decision actions, now in public preview, use Microsoft-Decision-1 to perform focused judgments such as classifying requests, routing tickets, and assessing urgency. Yes/No, Choice, and Score actions return structured results that workflows can act on directly. Bring AI into workflows without managing models: Managed AI Models in Logic Apps Automation (preview) provide ready-to-use AI capabilities without requiring developers to provision or manage model infrastructure. Together, these capabilities help organizations apply the right intelligence to each business process using workflows for predictable tasks, AI for focused decisions, and agents for more complex reasoning and action. Enterprise-ready automation, built for scale As automation expands across business systems, organizations need secure connectivity and reliable operations. At Ignite, we're enhancing Logic Apps Automation with built-in connectors for GitHub, Azure DevOps, Azure Monitor Logs, Azure Resource Graph, and Azure Advisor, along with virtual network integration for access to private enterprise resources. Learn more about these new capabilities in Logic Apps Automation. Building the future of intelligent enterprise automation The next generation of enterprise automation will bring workflows, AI agents, enterprise systems, and people together connecting applications and data while coordinating how work gets done. With the innovations announced at Microsoft Ignite 2026, Azure Logic Apps is helping organizations move from traditional integration and automation toward more intelligent business processes, built on the connectivity, reliability, and control enterprises depend on. Join us at Microsoft Ignite 2026 If you're attending Microsoft Ignite in San Francisco, join us to explore the latest Azure Logic Apps innovations, see demos, and connect with our product experts. Modernize legacy integration with Azure Logic Apps Reimagine agentic business processes with Logic Apps Automation How are you reimagining business processes with Logic Apps Automation? Give your agent a thousand tools: Connectors as MCP for AI Your agent wrote the workflow. Who watches it run? Stop by the Serverless Apps and Agents booth to meet our product team, see the latest capabilities in action, ask questions, and share what you're building. We look forward to seeing you there!Announcing HL7 General Availability and MLLP Connector Public Preview in Azure Logic Apps
Healthcare organizations run on HL7 v2.x. Admissions, lab results, orders and billing still move between EHR, LIS, RIS and HIS systems as pipe-delimited messages over long-lived TCP connections, and many of those interfaces have been running on BizTalk Server and the BizTalk Accelerator for HL7 (BTAHL7) for more than a decade. As these customers plan their modernization, the question we hear most is simple: can Azure Logic Apps run my healthcare interfaces? Today we are excited to announce two milestones that answer that question: The HL7 connector (Encode HL7 and Decode HL7) is now generally available for Azure Logic Apps Standard, rolled out to all production regions. The MLLP connector (Receive HL7 message from MLLP server, Send HL7 message to MLLP server and Send MLLP response) is now in public preview for Logic Apps Standard workflows running on the hybrid deployment option. Together, they give you the two building blocks of every HL7 v2.x integration: a parser and serializer that understands HL7 structure, and a transport that speaks the protocol your clinical systems already use. In this post we walk through what each connector does, how to set them up, and how they map to the BizTalk concepts you already know. Why HL7 v2.x and MLLP still matter Despite the growth of FHIR, HL7 v2.x continues to dominate real-time clinical workflows. It is deeply embedded in existing clinical systems, it uses text-based and predictable segments that are simple to develop against, and its acknowledgment (ACK/NACK) pattern provides the delivery confirmation that patient safety and auditability depend on. The Minimal Lower Layer Protocol (MLLP) is the transport that carries those messages. It is a lightweight framing protocol over TCP/IP: each HL7 message is wrapped with a start block character (VT, 0x0B) and an end block sequence (FS, 0x1C, followed by a carriage return, 0x0D). It is not HTTP, which is exactly why it has been hard to support in cloud-native integration platforms until now. Common HL7 message types you can process with these connectors include: Message type Purpose ADT Admission, discharge and transfer ORM General order message ORU Unsolicited observation results (for example, lab results) DFT Detailed financial transaction EPR Electronic patient record What is generally available: the HL7 connector The HL7 connector is a built-in connector that runs in-process with the Logic Apps Standard runtime, and it is supported in all Standard workflows, whether you host them in Azure or on your own infrastructure with the hybrid deployment option. It provides two actions. Operation Type What it does Parameters Encode HL7 Action Converts XML to an HL7 flat file Message to encode (required), Header to encode (required) Decode HL7 Action Converts an individual or batch HL7 flat file to XML Message to decode (required) Because the HL7 connector has no trigger of its own, you can start your workflow with any trigger that fits your scenario: an HTTP request, a Service Bus queue, a file or SFTP drop, or the new MLLP trigger described later in this post. Supported capabilities at GA The GA release covers the scenarios we see most often in BizTalk healthcare migrations: HL7 v2.x message handling with validation up to v2.6, using BizTalk HL7 schema releases up to v2.6. Individual message processing and batch message decoding (HL7 debatching). Acknowledgment parsing for versions 2.4, 2.5 and 2.6. Custom Z segments, supported when you add the Z segment node to your message schema. A simpler schema model: you upload only the message schema and its referenced schemas. Unlike BizTalk Server, you do not upload the common header schema (MSH_25_GLO_DEF.xsd) or the acknowledgment schemas (ACK_24_GLO_DEF.xsd and ACK_25_GLO_DEF.xsd), because the Logic Apps engine manages them for you. Current limitations Be aware of the following when you plan your migration: ACK generation is not supported, and ACK support does not extend to versions lower than 2.4. MSH overrides and partner-specific configuration are not supported. Z segments require a schema update; there is no dynamic discovery of custom segments. HL7 schemas must be stored in an integration account. Setting up an HL7 scenario in three steps Step 1: Prepare and upload your schemas You need an integration account in the same Azure subscription and region as your Standard logic app. Upload the HL7 flat file message schema and every schema it references. For example, the ADT_A01_231_GLO_DEF.xsd schema depends on datatypes_21.xsd, segments_21.xsd and tablevalues_21.xsd, so all four go into the integration account. Two tips from our early adopters will save you time: Keep the BizTalk naming convention for message schemas: <msgtype>_<subtype>_<version>_GLO_DEF, for example ADT_A01_231_GLO_DEF. The connector uses it to resolve the right schema for each message. Check the schema import locations. BizTalk uses the BTAHL7 prefix in schema locations; that prefix is not needed in Logic Apps. Step 2: Link your logic app to the integration account Before you use HL7 operations, link your Standard logic app to the integration account. Add the integration account callback URL to your logic app settings as the WORKFLOW_INTEGRATION_ACCOUNT_CALLBACK_URL environment variable. Step 3: Add Decode HL7 and Encode HL7 to your workflow Open your workflow in the designer (in the Azure portal or in Visual Studio Code), add a trigger, and then add the HL7 built-in actions. Decode HL7 takes the raw HL7 flat file in Message to decode and returns structured XML. Behind the scenes it extracts and validates the MSH header, builds the delimiters (field |, component ^, repetition ~, escape \), reads the message type and control numbers, resolves the matching schema from the integration account, and parses segments down to fields, components and subcomponents. Here is a simple ADT^A01 input with a custom Z segment: MSH|^~\&|balh|MCM|IFENG|sd|199112311501||ADT^A01|000001|P|2.1 EVN|A07|17760704010159-0600 ... ZM1|8329||testsample||abc The action outputs the header, the message body and any custom segments as separate, structured values. You do not have to deal with multipart messages the way you did with the BizTalk disassembler pipeline. Encode HL7 does the reverse. Provide the XML body in Message to encode and the XML header in Header to encode. The action validates both against their schemas, produces the MSH header and message flat files, and assembles them into a single HL7 message ready to send downstream. Figure 1: Decode HL7 turns an HL7 flat file into a header, a message body and custom segments as XML. Encode HL7 does the reverse. Troubleshooting tips If a message contains segments that the schema does not recognize, Decode HL7 falls back to a wildcard definition for those unrecognized segments instead of failing the whole message. Check your schema when you see unexpected unrecognized segments in the output. The segment terminator must be LF (\n) or CRLF (\r\n). Messages that do not follow this convention cause parsing errors. A schema path copied from a BizTalk project applies only to BizTalk environments; update it to point at the schemas in your integration account. What is in public preview: the MLLP connector Moving HL7 messages between systems in real time requires MLLP, and MLLP requires raw TCP listeners. That is why the MLLP connector is available for Standard workflows created with the hybrid deployment option, where your logic app runs on your own Azure Arc-enabled Kubernetes infrastructure and can open custom TCP ports. For many healthcare organizations this is also the right architecture: the integration runtime sits close to the on-premises clinical systems it talks to, while you author, deploy and monitor from Azure. Figure 2: The HL7 connector runs in Standard logic apps in Azure or on hybrid deployment. The MLLP connector requires hybrid deployment because it uses raw TCP. Operation Type What it does Key parameters Receive HL7 message from MLLP server Trigger Listens on a TCP port and starts a run for each HL7 message received Connection name, MLLP server host name or address, port number; optional Two-way (Request-Response) Send HL7 message to MLLP server Action Frames an HL7 message and sends it to a remote MLLP endpoint Connection name, host, port, HL7 message body Send MLLP response Action Returns a synchronous response to the originating system on the same connection and port Correlation ID (from the trigger), response message body How the message flows On the receive side, the MLLP server starts a listener on the configured port. When an upstream system connects and sends a framed message, the connector removes the MLLP framing and starts a workflow run with the de-framed HL7 message, which you can pass straight to Decode HL7. On the send side, the action opens a socket connection to the target host, wraps the message with the VT, FS and CR delimiters and sends it. Step 1: Open TCP ports on your hybrid logic app Logic Apps acts as the listener for MLLP traffic, so you need to open the ports you plan to use: On your logic app sidebar, under Settings, select Ingress. Find and expand the Additional TCP ports section. For each port that handles MLLP messages, specify the Target port and the Ingress traffic type. Step 2: Receive HL7 messages Create a blank workflow and add the Receive HL7 message from MLLP server trigger. In the connection pane, provide a connection name, the MLLP server host name or address and the port number, and then select Create new. Add a Decode HL7 action after the trigger to turn the incoming message into structured XML for routing, transformation with Data Mapper, or delivery to any downstream system through the Logic Apps connector ecosystem. Step 3: Reply on the same connection (two-way, preview) Many sending systems expect an acknowledgment on the same socket before they send the next message. To support this pattern: Select the trigger, open Advanced parameters on the Parameters tab, and set Two-way (Request-Response) to Yes. The trigger keeps the connection open while the workflow prepares a response. Add the actions that process the message and build your response, such as an HL7 ACK. Add the Send MLLP response action. For Correlation ID, select the Correlation ID output from the trigger; this identifies the connection to answer on. Put your ACK or other response in Response message body. Step 4: Send HL7 messages downstream To deliver messages to a downstream clinical system, add Send HL7 message to MLLP server to any workflow, create a connection with the target host and port, and map the HL7 message body, typically the output of Encode HL7. Preview considerations The MLLP connector is in public preview and subject to the Supplemental Terms of Use for Microsoft Azure Previews. MLLP operations are available only for Standard workflows that use the hybrid deployment option, because MLLP is a raw TCP protocol rather than an HTTP-based one. The MLLP trigger requires an empty workflow. Two-way synchronous communication on the same connection and port is in public preview. End-to-end pattern: an ADT feed Putting the pieces together, a typical admission feed looks like this: The EHR sends an ADT^A01 message over MLLP to your hybrid logic app. The Receive HL7 message from MLLP server trigger starts the run. Decode HL7 validates and parses the message against the ADT_A01 schema in your integration account. Your workflow routes on message type, transforms the payload with Data Mapper or XSLT, and calls downstream systems such as a lab system, a data platform or an API. Send MLLP response returns an acknowledgment to the EHR on the same connection. For outbound feeds, Encode HL7 rebuilds the flat file and Send HL7 message to MLLP server delivers it. Figure 3: An ADT feed end to end. The MLLP trigger receives the message, Decode HL7 parses it, Send MLLP response returns the ACK on the same connection, and Encode HL7 with Send HL7 message to MLLP server delivers it downstream. Notes for BizTalk Server customers Since its first release, BizTalk Server has supported healthcare scenarios through BTAHL7 and the MLLP adapter. The HL7 and MLLP connectors were designed so you can reuse what you have built: Aspect BizTalk Server Logic Apps Standard Pipeline disassembly Disassembler pipeline separates header, body and custom segments Action outputs directly provide structured values Schemas HL7 schemas plus global header and ACK schemas HL7 message schemas and dependencies only; no header or ACK common schemas ACK handling Generation and parsing through pipeline components Parsing of HL7 ACK/NACK for v2.4 to v2.6; generation not supported Z segments Supported through schema customization Supported when Z segments exist in the uploaded schema, without dynamic discovery Transport MLLP adapter MLLP connector (public preview) on hybrid deployment Your existing BizTalk HL7 schemas are the starting point: upload them, adjust import locations, and keep your naming conventions. If you are planning a larger migration, the Logic Apps Migration Agent can help you assess and convert your BizTalk applications. Get started Read the documentation: Integrate healthcare systems with HL7 and MLLP in Standard workflows. Learn how to create Standard logic app workflows for hybrid deployment on your own infrastructure. Working on a BizTalk healthcare migration? Ask your Microsoft account team to request help from our team through our white glove program at https://aka.ms/logicappswg. Join us at Microsoft Ignite in session BRK424, Modernize legacy integration with Azure Logic Apps, on November 19, 2026. We built these connectors alongside healthcare customers and partners who tested early builds and shared detailed feedback. Thank you. Try HL7 and MLLP in your workflows today, and let us know what you build and what you need next in the comments below.Azure AI Gateway is now generally available: Ship faster, stay in control
Today at Microsoft Ignite 2026, we're announcing the general availability of Azure AI Gateway, a fully managed Azure service that lets you set up a single, controlled path from your AI applications and agents to models and tools across providers. Developers build with the models and tools they choose, and platform teams manage access, enforce policies, control costs, and monitor usage from one place, without operating gateway infrastructure. Azure AI Gateway, previously in public preview as the AI Gateway tier of Azure API Management, is now a standalone product optimized for governing access to AI models and tools, with a roadmap focused entirely on AI. You can use it by itself with any app or agent, or together with Microsoft Foundry, where you build and run agents, and Microsoft Agent 365, where you manage them. Azure AI Gateway is available today in 17 Azure regions. To make it easy to get started, it offers a freemium, per-use pricing model with 10,000 free requests per gateway each month. Paid billing begins January 1, 2027. See the Regions and pricing section below for details. Why enterprise AI needs a unified governance layer Enterprise AI has moved beyond one app calling one model. Organizations use models from several providers, build agents that act through enterprise tools, and scale AI across teams. When each app manages its own credentials, routing, safety, and usage limits, governance becomes fragmented. Developers struggle to find approved models and tools, and platform teams can't see who is using what, what it costs, or which policies apply. Azure AI Gateway lets you move those controls out of individual apps and into one place, where they apply consistently to every app and agent you connect. How Azure AI Gateway works Apps and agents you connect call the gateway instead of calling each model or tool directly. On every request, the gateway authenticates the caller with Microsoft Entra ID or a gateway access key, enforces access rules and your policies, routes the request to the right model or tool, and records telemetry. Figure 1. Azure AI Gateway sits between callers and backends, governing every request that passes through it. What you can do with Azure AI Gateway Build with models and tools across providers Any model, one name: Use models from Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic, Amazon Bedrock, Google Vertex AI, or any OpenAI-compatible endpoint. Apps call each model by an alias you define, so you can switch models without changing app code. Routing and failover: Route by priority, weight, or custom conditions, with configurable failover, or let Model Router (preview) choose by cost or quality. Consolidated tools: Federate MCP servers and turn OpenAPI specs, connectors, and API Management APIs into MCP tools. Multiple MCP spec versions are supported, including the latest (July 2026). The APIs you know: Call models through an OpenAI-compatible API or the Anthropic Messages API and connect agents to tools from any MCP client. Govern and observe AI interactions Access with Entra ID: Built-in roles control who can use models and tools. Provider keys and tool credentials never reach app code. Safety on every prompt: Screen prompts and responses with Azure AI Content Safety. Only approved tools: Curate and block tools at the gateway, or through Microsoft Agent 365 policies. Protection from poisoned tools (preview): Through the Microsoft Agent 365 integration, Microsoft Defender and Microsoft Purview inspect tool calls and results and block threats before an agent acts. Delegated identity: With on-behalf-of (OBO) authentication, tools act with the signed-in user’s own permissions. Every call on record: Record the caller, target, tokens, and outcome of each model and tool call, trace each call to its agent, and export the data over OpenTelemetry to Application Insights, Datadog, Splunk, Grafana Cloud, or any OTLP endpoint. Private by design: Private Link (preview) for inbound calls, VNet integration (preview) for private backends, IP filtering, and managed identity. Control AI spend as adoption scales See who spends what: Track tokens and estimated cost by user, team, app, agent, provider. Enforced budgets: Cost limits stop new requests once estimated spend reaches a budget. Fair sharing: Token and request limits keep one caller from crowding out the rest. Discover, build, and operate in your existing workflow Coding agent plugin: Developers find approved models and tools and connect their apps from their coding agent. Portal, CLI, Bicep, and REST API: Configure in the portal or with the CLI, then deploy the same setup as code from your CI/CD pipelines with Bicep or the REST API. See Azure AI Gateway in action From connecting models and MCP tools to securing access, controlling costs, and monitoring AI traffic, this demo shows how Azure AI Gateway helps you run AI applications with confidence. Extend AI governance across your Microsoft ecosystem Already using Microsoft Foundry, Microsoft Agent 365, or Azure API Management? Azure AI Gateway works with all three. Microsoft Foundry: Foundry has governance built in for its resources and projects. When AI spreads across teams, Foundry resources, subscriptions, and other providers, the gateway adds a shared layer on top. In a hub-and-spoke model, the gateway is the hub: a central platform team sets the rules once, and developers keep building in their Foundry projects, the spokes, using approved models and tools without managing credentials. Projects can share one deployment, including PTU, and fail over to another Foundry resource or provider. Foundry prompt agents can use gateway models through a model connection (preview), without code changes. Microsoft Agent 365: Agent 365 discovers the gateway’s MCP servers and lets you set tool policies. The gateway enforces those policies, alongside its own, on every tool call, with added threat protection (preview) from Defender and Purview. Regions and pricing Azure AI Gateway is available today in 17 Azure regions: East US, East US 2, East US 2 EUAP, West US, West US 2, Central US, North Central US, South Central US, Canada East, West Europe, North Europe, UK South, France Central, Sweden Central, Australia East, Japan East, and Southeast Asia. Azure AI Gateway offers a freemium, per-use pricing model with 10,000 free requests per gateway each month. Paid billing begins January 1, 2027. Monthly gateway requests Service fee Additional request charges Up to 10,000 Free None More than 10,000, up to 10 million $500 per month, per gateway, billed hourly None (includes 10 million requests) More than 10 million $500 per month, per gateway, billed hourly $20 per additional million requests, billed in increments of 10,000 requests Prices are in US dollars and may vary by region. Exact regional prices will be available when billing begins. Get started with Azure AI Gateway Create a gateway at ai.gateway.azure.com. It’s ready in about a minute and free to start. Then: Connect an existing model and give it an alias. Expose the MCP tools your agents need. Give your team access with an AI Gateway role. Set a cost limit. Point your app or agent at the gateway. Or start from your coding agent. Install the Azure AI Gateway plugin, and it finds approved models and tools and connects your app for you. Explore the documentation and quickstarts at ai.gateway.azure.com/docs.1.2KViews1like0CommentsTune your Logic Apps Standard runtime from the portal
Until now, the answer lived in host.json . To change a value in Azure, you opened Advanced Tools, went into Kudu, stopped your logic app, hand-edited JSON with a key you copied from the docs, saved, and restarted. Nothing on screen told you the default, or whether someone had already changed it. That's the gap the new Workflow runtime settings tab closes. What is the new configuration experience Workflow runtime settings is a new tab on the Configuration page of every Logic Apps Standard app in the Azure portal. It sits next to General settings, Health check, and Path mappings, and it's generally available today. The tab turns the host and app settings we document for Standard into a form. You get 11 collapsible areas, each with labeled fields that show the value in effect. Every field has an info tooltip with a plain-language description, the exact setting key, and the default. Change one or more values, select Apply, and the portal writes the right setting to host.json or app settings for you, then restarts the host so the new value is live immediately. No Kudu. No hand-edited JSON. No guessing the key. Why it is important Standard gives you a single-tenant runtime, and with it the ability to tune throughput, limits, and retries for your workload. But a setting you can't find is a setting you don't use. The first problem was discoverability. The settings that govern scaling, throttling, and concurrency lived in a long reference table in the docs, with nothing in the portal pointing to them. The second was context: a key like Runtime.FlowTriggerDispatchingJob.MessageProcessingConcurrencyLimit doesn't tell you which behavior it changes or what a sensible value looks like. The third was the baseline. If you didn't know the default, you couldn't tell whether a value had been tuned, or how to put it back. The new tab deals with all three, and it doesn't add new settings to learn. It's a distillation of the settings already published in our docs, presented where you manage the app. Before and after Task Before Now Find the right setting Search the host settings reference in the docs Expand the matching area on the Workflow runtime settings tab See the current value Open host.json in Kudu; a missing key means the default applies The field shows the value in effect Know the default Look it up in the reference table Hover the info icon next to the field Change a value Stop the app, edit host.json in Kudu, save, restart Edit the field and select Apply Back out an edit Edit the JSON again Select Discard before applying, or enter the default shown in the tooltip Walkthrough You will find the new configuration settings under Configuration> Workflow runtime settings tab Follow the steps below to start exploring it: In the Azure portal, open your Standard logic app. On the resource menu, under Settings, select Configuration. Select the Workflow runtime settings tab. The 11 configuration areas appear, collapsed. Expand an area, for example Built-in operations, to see its settings grouped by operation type. Hover the info icon next to any field to read what it does, its setting key, and its default. Change the values you need, then select Apply. Select Discard to drop unsaved edits, or Refresh to reload the current values. You can explore each configuration using the tooltip button. It explains the setting, notes that the default values and also the any range or possible values. It will also provide you the configuration entry this value is adding to your host.json. For example for the HTTP Request Timeout, it gives you Runtime.Backend.HttpOperation.RequestTimeout as the key. The configuration areas Area What it controls Examples (default) Built-in operations Retries, timeouts, and request size for built-in HTTP, HTTP Webhook, and Azure Functions operations HTTP Request Timeout (00:03:45), HTTP Default Retry Count (4) Connectors - Managed Authentication audience, timeouts, retries, and webhook intervals for managed (Azure-hosted) connectors Connector Request Timeout (00:02:00), Connector Webhook Wake-Up Interval (01:00:00) Connectors - Service Provider Settings for the built-in service provider connectors your workflows use Service Bus Message Sender Pool Size Per Processor Count (64), Key Vault Max Secrets To Return (25) Content & message limits Chunking, pagination, input and output size, and when content moves from table storage to blob storage Maximum content size per input or output (104,857,600 bytes), Maximum page count (1,000) Job orchestration & throughput Job dispatchers per processor core and job queue partitioning Workers per processor count (192) Loops & variables For each and Until limits, For each parallelism, and variable size For each degree of parallelism (20), Until limit for stateful workflows (5,000) Retry policy Upper and lower bounds for retry policies on workflow operations Maximum retry count (90), Minimum retry interval (00:00:05) Run lifecycle & history Action and function timeouts, run duration, and history cleanup Action job execution timeout (00:10:00), Flow run timeout (90 days) Scaling Runtime scale monitoring Runtime scale monitoring (On or Off) Storage Retries and timeouts for blob, table, and queue requests from the runtime Blob server timeout (00:00:30), Table and queue server timeout (00:00:16) Triggers Function-based trigger listeners and drain mode, recurrence-based trigger state, and trigger concurrency Maximum Run Concurrency (100), Maximum Waiting Runs (200) Feature highlights Settings for the connectors your app uses The Connectors - Service Provider area doesn't list every built-in connector in Logic Apps. It shows settings for the ones your workflows use. In the walkthrough app, that's Azure Tables, Key Vault, Service Bus, and Service Bus Peek Lock, followed by a short block of switches that apply to all service providers, such as Validate action and trigger operation IDs. That changes what you're looking at. Instead of scanning SFTP or SQL settings in an app that never calls them, you see the settings that can affect your app: for example, Azure Tables Max Entities To Return (255) or Key Vault Max Secrets To Return (25). Managed connectors get their own area, with the authentication audience, request timeout (00:02:00), retry count and intervals, and webhook wake-up interval. Scaling, throttling, and concurrency, out of the config file When a load test shows a bottleneck, these are the settings you reach for. They used to be the hardest to find. Now each one has a field, a default, and a description. Job orchestration & throughput: 192 dispatcher workers per processor core for stateful runs and 192 for stateless runs, 4 partitions in the job definitions table, and 1 job triggers queue. Triggers: Maximum Run Concurrency (100), Maximum Waiting Runs (200), and Message Processing Concurrency Limit (1). For function-based triggers, you also get the list of triggers with concurrency enabled (Service Bus and Event Hubs in the walkthrough app), plus drain mode and dynamic listener timings. Loops & variables: For each degree of parallelism (20). Set it to 1 to run iterations one after another. Scaling: an On or Off switch for runtime scale monitoring. Defaults where you can see them Every field shows the value in effect, and every tooltip shows the default and the setting key. That's three answers on one screen: what the app runs with, what it would run with if nobody had touched it, and the exact key to look for in your project. The key matters if you deploy from source control. host.json travels with your deployment, so a value you change in the portal can be overwritten the next time your pipeline deploys. Once you've found the right value in the portal, copy the key from the tooltip into your project's host.json , under extensions.workflow.Settings : { "version": "2.0", "extensionBundle": { "id": "Microsoft.Azure.Functions.ExtensionBundle.Workflows", "version": "[1.*, 2.0.0)" }, "extensions": { "workflow": { "Settings": { "Runtime.Trigger.MaximumWaitingRuns": "100" } } } } Those values will update the correct file locations (host.json and appsettings). Use the portal to find and test the correct values in the files and apply on your source controled files to keep it. One value, every workflow Before you change anything, keep scope in mind. These are app-level settings. A value you apply here becomes the runtime configuration for every workflow in the logic app, not only the one you're debugging. Trigger concurrency is the clearest example. Set Maximum Run Concurrency to 1, and each qualifying trigger in the app can start one run at a time, with further runs waiting in line up to the Maximum Waiting Runs limit (200 by default). These trigger concurrency settings apply to workflows that start with a recurrence-based trigger for built-in, service provider-based connectors. If only one workflow needs to process one run at a time, configure concurrency on that workflow's trigger instead. Selecting Apply restarts the host. Treat a change the way you'd treat any restart: try it in a nonproduction environment first, and apply it in production when a brief restart won't hurt. Feedback This tab started from a simple observation: the runtime settings were hard to find and easy to get wrong. It's our first pass at putting them where you work, and I want to know how close we got. Which settings do you change most often? Which ones are missing? Which descriptions still leave you guessing? Open an issue on the Logic Apps UX GitHub repo and tell me. I read them, and they shape what we build next. For the full reference behind every field, see Edit app and host settings for Standard logic apps.Logic Apps Standard custom code now supports .NET 10
The latest Azure Logic Apps (Standard) extension for Visual Studio Code (VS Code) now supports .NET 10 custom code. You can create new .NET 10 local-function projects and migrate your existing .NET 8 projects without turning them into separate Azure Functions apps. Check your prerequisites Install the Azure Logic Apps (Standard) extension for VS Code, version 5.1013.4 . Use Logic Apps Standard extension bundle 1.194.31 . After the extension's dependency setup completes, the .NET 10 software development kit (SDK) and runtime should be installed in its managed dependencies folder. On Windows, the default .NET location is: %USERPROFILE%\.azurelogicapps\dependencies\DotNetSDK Check that installation, rather than relying on the dotnet command elsewhere on your PATH . If you've customized the extension's dependency location, check the configured location instead. New projects target .NET 10 When you create a new custom-code project through the extension, .NET 10 is now the only supported target. The .NET 8 option has been removed for new projects. Existing .NET 8 projects still need a configuration migration before they target .NET 10. Updating the extension isn't the same as retargeting your project. Unchanged project will continue to run on .NET 8 until the configuration changes below are applied. If you use the C# code action If your workflow uses the C# code action, add the runtime setting to your Logic Apps project's settings - either in a local project or on an Azure application. Set LOGIC_APPS_CUSTOMCODE_DOTNETVERSION to net10.0 . Migrate an existing .NET 8 project You don't need to start with a new workspace. Back up your workspace, including local configuration, before making the changes below. Paths are relative to each project's folder. Changes in the custom-code project File or setting Change Project .csproj : target framework Set TargetFramework to net10.0 . Keep the project as a library. Project .csproj : SDK packages Microsoft.Azure.Workflows.Webjobs.Sdk : 1.4.1 Microsoft.Azure.Functions.Worker.Sdk : 2.0.7 Project .csproj : supporting packages Align dependencies as needed. Our migration required: Microsoft.Azure.Functions.Worker : 2.51.0 Existing Microsoft.Extensions.Logging : 10.0.0 Existing Microsoft.Extensions.Logging.Abstractions : 10.0.0 Project .csproj : dependency copying and publication Set CopyLocalLockFileAssemblies to true . Keep build-triggered publication into the Logic Apps folder. .vscode\settings.json Update the framework segment of azureFunctions.deploySubpath to net10.0 . Those package versions describe the configuration we tested, not a universal minimum dependency set. Resolve the dependencies your project actually needs rather than copying every package from a sample. A sample project file will look like this <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <IsPackable>false</IsPackable> <TargetFramework>net10.0</TargetFramework> <AzureFunctionsVersion>v4</AzureFunctionsVersion> <OutputType>Library</OutputType> <PlatformTarget>AnyCPU</PlatformTarget> <LogicAppFolderToPublish>$(MSBuildProjectDirectory)\..\{your logic app target folder}</LogicAppFolderToPublish> <CopyToOutputDirectory>Always</CopyToOutputDirectory> <SelfContained>false</SelfContained> <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> </PropertyGroup> <ItemGroup> <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Abstractions" Version="1.3.0"/> <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="2.51.0"/> <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="2.0.7"/> <PackageReference Include="Microsoft.Azure.Workflows.Webjobs.Sdk" Version="1.4.1"/> <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.0"/> <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.0"/> </ItemGroup> <Target Name="TriggerPublishOnBuild" AfterTargets="Build"> <CallTarget Targets="Publish"/> </Target> </Project> Changes in the Logic Apps project File or setting Change local.settings.json : custom-code runtime Set Values.LOGIC_APPS_CUSTOMCODE_DOTNETVERSION to net10.0 . local.settings.json : host runtime flag Keep Values.FUNCTIONS_INPROC_NET8_ENABLED set to 1 . This is still required. .vscode\launch.json : coordinated debugging Use a launch configuration with: type=logicapp and request=launch funcRuntime=coreclr customCodeRuntime=coreclr isCodeless=true Verify the migration Save all files, restore, and build. Confirm publication under lib\custom\net10.0 in the Logic Apps folder, then run the workflow that calls your edited function and verify its breakpoint. Use the ready-made migration skill We've prepared the logicapps-custom-code-net10-migration skill to guide a coding agent through the same process. It inspects your workspace, plans configuration changes before applying them, and guides build and publication verification. It preserves your function and workflow implementations rather than rewriting them. The skill is available in Awesome Copilot. With GitHub CLI (command-line interface) version 2.90.0 or later, inspect the skill and install it for Copilot across projects. These skill commands are currently in preview. gh skill preview github/awesome-copilot logicapps-custom-code-net10-migration gh skill install github/awesome-copilot logicapps-custom-code-net10-migration --agent github-copilot --scope user Installation makes the skill available to Copilot; it doesn't run the migration. After installation, you can ask your agent: Migrate this Logic Apps Standard .NET 8 custom-code workspace to .NET 10 using the logicapps-custom-code-net10-migration skill. Preserve my workflows, back up the project first, and include coordinated VS Code debugging. Keep the host and deployment settings in view The custom-code target framework isn't the Logic Apps host runtime. Keep the existing host settings, including FUNCTIONS_WORKER_RUNTIME=dotnet . Don't switch the host to dotnet-isolated just because the custom code targets .NET 10. Preserving your existing code is the migration's starting point, not a guarantee that it will build and run unchanged. Use the build and an executed local function to check the result. For Azure execution, the deployed Logic Apps application settings must include both LOGIC_APPS_CUSTOMCODE_DOTNETVERSION=net10.0 and FUNCTIONS_INPROC_NET8_ENABLED=1 . The .NET 8 host flag is still required even though your custom code targets .NET 10. When you deploy through the Logic Apps extension in VS Code, these settings are copied to the Azure app. If you deploy through a pipeline, make sure your deployment configuration explicitly includes both application settings. A local settings file alone doesn't configure the Azure app, so verify the deployed runtime configuration after deployment. The migration skill doesn't change Azure resources as a side effect. Try the updated extension with one of your custom-code projects. If migration or debugging needs a step we've missed, share the configuration and the symptom in the comments, without credentials or private data. I want to hear where the build or debugging experience still gets in your way.1KViews0likes15CommentsMigrate NuGet-based Logic Apps Standard apps and custom built-in connectors to .NET 10
Less than you might fear. You don't change a line of C#, and you don't touch your workflow definitions. The work is retargeting your projects, resolving a couple of dependency conflicts, running the right host locally, and changing a handful of app settings in Azure. Those last two are where people get stuck, so I spend most of this post on them. This is a companion to Logic Apps Standard custom code now supports .NET 10. That post covers custom-code (local function) projects. This one covers NuGet-based applications and the custom built-in connectors they consume, and it answers the questions you left in the comments on the custom code post. We validated every step below end to end, locally and in Azure, with a NuGet-based sample app and a custom built-in connector. Which post do you need? Your Logic Apps Standard app What to do Workflows only, bundle-based No project changes. The platform moves the app to the out-of-proc host. Workflows plus a custom-code (local function) project Follow the custom code .NET 10 post. NuGet-based project, with or without custom built-in connectors Follow this post. NuGet-based project that also has a custom-code project Use this post for the app and connectors, and the custom code post for the function project. Your code stays the same Your code don't change. Keep the [assembly: WebJobsStartup] attribute, your IWebJobsStartup.Configure method and your IServiceOperationsProvider implementation exactly as they are. Your workflow definitions don't change either. You don't add an isolated worker project or a Program.cs file. We validated this with a sample custom built-in connector that exposes an action, locally and in Azure. That tells you the model works. It doesn't tell you your connector works. Your connectors and their dependencies still need application-specific testing, and I come back to that in the limitations section. First, understand which host runs your app A connector built for net10.0 needs a .NET 10 host. The .NET 8 host can't load it: every type fails with a missing System.Runtime 10.0.0.0 reference. So the whole migration comes down to two things: building for net10.0 , and making sure a .NET 10 host runs the result. Azure and your local tools choose that host in different ways, and this is the part that catches people out: Where FUNCTIONS_WORKER_RUNTIME What selects the .NET 10 host Azure dotnet (unchanged) Removing LOGICAPP_INPROC_REDIRECT . Without it, the platform runs your app on the out-of-proc host on .NET 10. Local (Azure Functions Core Tools) dotnet-isolated Core Tools ignores LOGICAPP_INPROC_REDIRECT . With dotnet it always picks its .NET 8 in-process host. With dotnet-isolated , Core Tools 4.16.0 or later uses its main host, which runs on .NET 10. dotnet-isolated doesn't move you to the isolated worker model. The Workflows runtime and your connector still load into the host process; the value only changes which host Core Tools starts. That's also why it's a local-only value. Keep it out of your Azure app settings and deployment templates. This is a current limitation of the the extension and we are working to remove this extra configuration step. Check your prerequisites The .NET 10 SDK, version 10.0.403 or later. The Azure Logic Apps (Standard) extension for VS Code, version 5.1013.4, installs it in the extension's managed dependencies folder. On Windows the default is %USERPROFILE%\.azurelogicapps\dependencies\DotNetSDK . Azure Functions Core Tools 4.16.0 or later, the first version whose main host runs on .NET 10. The extension installs a managed copy in %USERPROFILE%\.azurelogicapps\dependencies\FuncCoreTools . An older copy installed through npm and earlier on your PATH (4.12.0 in our testing) runs on .NET 8 and fails to start the app. Microsoft.Azure.Workflows.WebJobs.Extension 1.170.91 or later. The current version at the time of this post on NuGet is 1.194.31, which is the version we validated. Use the latest version you have available as it will have the latest product improvements and fixes. Microsoft.NET.Sdk.Functions 4.5.0 or later. We validated 4.5.0 and 4.6.0. Write access to the package feed where you publish your connector packages. A build agent image with the .NET 10 SDK for your pipeline. Keep your current deployment stable while you migrate If your app runs on .NET 8 today, leave its app settings alone until your .NET 10 build is validated and ready to deploy. Retaining the existing app settings preserves the current compatibility configuration while you prepare and validate the migration. For NuGet-based apps, that includes LOGICAPP_INPROC_REDIRECT=1 , the setting that keeps your app on the legacy .NET 8 in-proc host. Remove it early and the app moves to the new host on its next restart, before your .NET 10 build is in place. Check your pipelines too. A release that rebuilds app settings from a template can drop the redirect without anyone noticing. Don't treat this as a reason to wait. .NET 8 apps keep running after end of support, but they no longer receive security fixes. Plan the migration now. Update your project files Work on a branch, and back up any local configuration before you start. This table lists every file that changed in our validated migration. Repeat the connector changes for every connector project your app consumes. File Change global.json (repository root and Logic Apps project folder) Set the SDK version to 10.0.403 or later, with rollForward set to latestPatch . A leftover 8.0 pin fails the build with NETSDK1045 . Connector .csproj Set TargetFramework to net10.0 . Reference Microsoft.Azure.Workflows.WebJobs.Extension 1.194.31. Add direct references for any NU1605 downgrades restore reports. Increment the package version (2.0.0 in our sample) so you can tell which connector loaded. Connector startup and provider classes No change. Connector test projects Set TargetFramework to net10.0 . Logic Apps .csproj Set TargetFramework to net10.0 . Reference Microsoft.NET.Sdk.Functions 4.5.0 or later, Microsoft.Azure.Workflows.WebJobs.Extension 1.194.31 and your new connector package version. Keep the targets that copy the lib folder and your artifacts into the publish output. host.json Remove any extensionBundle section. Keep version 2.0 and your existing logging and settings. local.settings.json Set FUNCTIONS_WORKER_RUNTIME to dotnet-isolated . .vscode/settings.json Point deploySubpath at bin\Release\net10.0\publish . .vscode/tasks.json Set the cwd of the func host start task to bin\Debug\net10.0 , in every operating system block. Build and deployment scripts Replace net8.0 output paths with net10.0 . Pin the SDK Update global.json in the repository root and in the Logic Apps project folder: { "sdk": { "version": "10.0.403", "rollForward": "latestPatch" } } Retarget the connector and resolve downgrades Restore is where the first failure shows up. In our sample, retargeting the connector with Workflows 1.194.31 produced NU1605 package downgrade errors, and two direct references fixed them: net10.0 true Contoso.LogicApps.Connectors.Inventory 2.0.0 Those were the right pins for our connector's dependency graph. Yours may need different ones, so read the NU1605 output and pin what it names rather than copying ours. If restore also reports vulnerability warnings, review them; don't suppress them as part of the migration. Then build, pack, and publish the new version to your feed: dotnet build -c Release dotnet pack -c Release -o ./nupkg dotnet nuget push ./nupkg/Contoso.LogicApps.Connectors.Inventory.2.0.0.nupkg --source If your Logic Apps project references the connector as a project reference rather than a package, skip the pack and push. The retarget and the dependency fixes still apply. Retarget the Logic Apps project The relevant parts of the project file: <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <TargetFramework>net10.0</TargetFramework> <AzureFunctionsVersion>v4</AzureFunctionsVersion> </PropertyGroup> <ItemGroup> <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="4.5.0" /> <PackageReference Include="Microsoft.Azure.Workflows.WebJobs.Extension" Version="1.194.31" /> <PackageReference Include="Contoso.LogicApps.Connectors.Inventory" Version="2.0.0" /> </ItemGroup> <!-- Keep your existing None/Update items and CopyDynamicLibraries target. --> </Project> Don't remove Microsoft.NET.Sdk.Functions . It generates bin\extensions.json , which registers your connector with the host. Without it, the connector is missing from the build output. A NuGet-based app loads the Workflows runtime from your package, not from an extension bundle, so host.json needs no bundle: { "version": "2.0" } Version 5.1013.4 of the extension have a configuration bug. It is ignoring the following extension configuration set: "azureLogicAppsStandard.enableProjectConsistencyChecks": false With that your host.json file will include the extension bundle setting again when the project opens: "extensionBundle": { "id": "Microsoft.Azure.Functions.ExtensionBundle.Workflows", "version": "[1.*, 2.0.0)" } Remove it before pushing to source control or running the application. We are working on a fix for this issue which will ship with the next version of the bundle. Why a net8.0 package works in a net10.0 project Microsoft.Azure.Workflows.WebJobs.Extension targets net8.0 . That doesn't stop a net10.0 project from referencing it: NuGet treats net10.0 as compatible and selects the package's net8.0 assets. What has to be .NET 10 is the host that runs your app. There's one side effect worth knowing about. On net10.0 , the SDK resolves the package's ASP.NET Core framework reference to version 10, which already contains Microsoft.Extensions.DependencyInjection and related assemblies, so the build leaves the package copies out of your output. That's expected. The .NET 10 host supplies them, which is one more reason the app only runs on that host. Run and verify locally Set the worker runtime in local.settings.json and keep your other values as they are: { "IsEncrypted": false, "Values": { "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated" } } Make sure Core Tools 4.16.0 or later is the func that runs. If you start the host from a terminal or a script, check that the managed copy, not an older npm install, comes first on your PATH . The version banner tells you which one started. Stop the host serving this project if it's running, then restore and build the Logic Apps project. Start the host from bin\Debug\net10.0 . Check the host log. There should be no '/serviceProviders/' ... is not valid error, and your workflows should be listed. Run a workflow for every operation you ship, triggers included, and check the run history. Optionally, open a workflow in the designer, select Built-in, and confirm your connector's operations appear. You may see Could not find the .azurefunctions folder in the deployed artifacts of a .NET isolated function app in the log. It's a warning that comes with the dotnet-isolated selection, and the workflows still run. Update the Azure app settings In Azure, the platform selects the .NET 10 host when LOGICAPP_INPROC_REDIRECT is absent, and FUNCTIONS_WORKER_RUNTIME stays dotnet . These are the settings we changed and the ones we left alone: Setting Action AzureFunctionsJobHost__extensionBundle__id Delete. AzureFunctionsJobHost__extensionBundle__version Delete. App settings override host.json , so removing the bundle from the file alone isn't enough. LOGICAPP_INPROC_REDIRECT Delete if present. It forces the legacy .NET 8 host. FUNCTIONS_WORKER_RUNTIME Keep dotnet . dotnet-isolated is the local-only value. FUNCTIONS_EXTENSION_VERSION Keep ~4 . APP_KIND Keep workflowApp . FUNCTIONS_INPROC_NET8_ENABLED Not required. It's harmless if it's left over from .NET 8. netFrameworkVersion (site configuration) No change. It stays v8.0 and doesn't decide which runtime loads. The extension bundle settings are the easiest to miss. Apps created in the Azure portal usually get them by default. If either is present, the host loads the Workflows runtime from the bundle instead of your package, your connector never registers, and the log reports that '/serviceProviders/' is not valid. Your deployed package can be perfectly correct and still fail this way. Keep your deployment template at dotnet as well, and make sure it doesn't add the bundle settings or the redirect back on the next release. Deploy and verify in Azure Update your pipeline to build with the .NET 10 SDK, publish a Release build, and deploy the contents of bin\Release\net10.0\publish . Deploy to a non-production app or deployment slot first. For an existing app, stop it, change the app settings, deploy the .NET 10 package, and then start it. In that order, the new package never starts under the old configuration. Check the host log for the '/serviceProviders/' ... is not valid error. It shouldn't be there. Confirm that each workflow that uses your connector shows its callback URL, and that a test run succeeds. Optionally, open Process Explorer in Kudu and confirm the loaded modules: CoreCLR 10, your connector DLL at its new version, and the Workflows runtime at 1.194.31. That's the reliable way to see which runtime is running, because the settings don't tell you. Compare run history with the .NET 8 version, then promote the same build and the same settings to production. A local settings file doesn't configure the Azure app. After each deployment, check the app settings on the deployed resource rather than trusting the template. If you need to roll back, redeploy the .NET 8 package and restore LOGICAPP_INPROC_REDIRECT=1 . Restoring the setting on its own isn't enough, because the .NET 8 host can't run a .NET 10 connector. Symptoms and causes If something fails, start here. These are the errors we hit during validation: Symptom Cause and fix NETSDK1045: The current .NET SDK does not support targeting .NET 10.0 A global.json pin or the selected SDK is still 8.0. Pin 10.0.403 or later. NU1605 package downgrade errors on restore Transitive dependency versions in your connector. Add direct references for the packages restore names. Locally: Could not load file or assembly 'Microsoft.Extensions.DependencyInjection, Version=9.0.0.0' FUNCTIONS_WORKER_RUNTIME is dotnet , so Core Tools started its .NET 8 in-process host. Set dotnet-isolated in local.settings.json . Locally: Could not load file or assembly 'System.Text.Json, Version=9.0.0.0' An older Core Tools whose host runs on .NET 8 is first on your PATH . Use 4.16.0 or later. '/serviceProviders/' ... is not valid , and no callback URL An extension bundle is configured in host.json or in the AzureFunctionsJobHost__extensionBundle__* app settings. Remove both. Connector and bin\extensions.json missing from the build output Microsoft.NET.Sdk.Functions was removed from the Logic Apps project. Add it back. Use the migration skill We've prepared the logicapps-nuget-connector-net10-migration skill to guide a coding agent through the same process. It inspects your solution, plans configuration changes before applying them, and guides build and test verification. It preserves your connector code and workflows rather than rewriting them, and it doesn't change Azure resources: it lists the app-setting changes for you to make. The skill is available in the custom-connector-migration-net10 repository, with a working sample. The main branch holds the migrated .NET 10 version and the net8.0 branch holds the .NET 8 baseline, so you can try the skill on the sample before your own projects. With GitHub CLI (command-line interface) version 2.90.0 or later, inspect the skill and install it for Copilot across projects. These skill commands are currently in preview. gh skill preview wsilveiranz/custom-connector-migration-net10 logicapps-nuget-connector-net10-migration gh skill install wsilveiranz/custom-connector-migration-net10 logicapps-nuget-connector-net10-migration --agent github-copilot --scope user Installation makes the skill available to Copilot; it doesn't run the migration. After installation, you can ask your agent: Migrate this NuGet-based Logic Apps Standard app and its custom built-in connector to .NET 10 using the logicapps-nuget-connector-net10-migration skill. Preserve my connector code and workflows, back up the projects first, and list the Azure app settings I need to change. Note: we're submitting this skill to Awesome Copilot. When it's available there, we'll update this post with the new install commands. Your questions, answered Do I need to change how my custom built-in connector registers? No. The existing registration model remains applicable: retain your IWebJobsStartup registration and IServiceOperationsProvider implementation. We validated a custom built-in connector with this model on the .NET 10 host, locally and in Azure. Your connectors and their dependencies still need application-specific testing. Microsoft.Azure.Workflows.WebJobs.Extension targets net8.0. Can a net10.0 app reference it? Yes. The package's net8.0 target doesn't prevent a net10.0 application from referencing it. A target framework isn't a requirement that the consuming application use exactly that framework. What does have to be .NET 10 is the host that runs your app. You still need to validate dependency compatibility, and restore tells you where to look. I'm already on 1.194.31. Do I need to downgrade to 1.170.91? No. 1.194.31 is newer than the 1.170.91 minimum in our migration guidance, and it's the version we validated. Stay where you are. Do I need to move to the isolated worker model? No. You don't add a worker project or a Program.cs file, and your connector still loads into the host process. dotnet-isolated is only the value that makes Core Tools start its .NET 10 host on your machine. In Azure, FUNCTIONS_WORKER_RUNTIME stays dotnet . What should I do with my existing .NET 8 deployment in the meantime? Keep its existing app settings. They preserve the current compatibility configuration while you prepare and validate the migration. Remove LOGICAPP_INPROC_REDIRECT when you deploy the .NET 10 package, not before. When will the official documentation cover NuGet-based apps and custom built-in connectors? We know you need explicit guidance for this scenario, and this post is that guidance today. We don't have a confirmed publication date for the Microsoft Learn update. Don't wait for it: migrate to .NET 10 at your earliest opportunity. Before you migrate: what we haven't covered We validated a sample connector with an action, not yours, and not a connector with triggers. Connectors that implement IServiceOperationsTriggerProvider , connectors with their own converters, and connectors with third-party libraries that pin older framework versions are where I'd expect surprises. Test every operation. We haven't validated an app that combines a NuGet-based project with a custom-code project. In our sample, the generateDebugSymbols prelaunch task in VS Code failed, because it looks up an extension bundle path and a NuGet-based project doesn't have one. Don't add a bundle to work around it; start the host from bin\Debug\net10.0 instead. We are working on a fix for this problem. The Microsoft Learn article Create custom built-in connectors for Standard workflows still describes a .NET Core 3.1 class library project. Until it's updated, use this post as the reference for the target framework. Don't pin your app to a specific extension bundle or Functions host version. Pinned apps needed manual updates during the out-of-proc migration, and they will again every time the platform moves. Call to action Retarget one connector this week and run it against a non-production app. If something fails, check the symptoms table first. If your error isn't there, post the connector shape (actions, triggers, converters), the package versions, and the error in the comments, without credentials or private data. I'll take the patterns back to the team and fold them into this post and the skill.227Views0likes0CommentsLogic Apps Aviators Newsletter - November 2026
In this issue: Ace Aviator of the Month News from our product group News from our community Ace Aviator of the Month November 2026's Ace Aviator: Steef-Jan Wiggers Coöperatie VGZ What's your role and title? What are your responsibilities? I'm a Domain Architect Technology in the Business Change department at VGZ, one of the largest health insurers in the Netherlands. I'm responsible for defining architecture building blocks and target architectures. I also investigate which technologies can help us and what changes our IT landscape needs to support the IT capabilities VGZ requires. Can you give us some insights into your day-to-day activities and what a typical day in your role looks like? Each week starts on Monday with our week start, where I meet with peers on a range of architectural topics. From there, no two weeks are the same. I create target architectures for IT capabilities such as integration, cloud, artificial intelligence and, most recently, search. These building blocks describe the “what” and feed into solution architecture, which works out the “how”. Getting to a well-defined target architecture means talking every day with peers and stakeholders across the organisation. I also make time to explore new technology hands-on, to see whether it fits our needs. I share what I find internally in what we call Business Change colleges, knowledge sessions for colleagues. And I'm in frequent contact with Microsoft, both the local team in the Netherlands and the product groups in Redmond. What motivates and inspires you to be an active member of the Aviators/Microsoft community? I've worked in integration for over 20 years. I started with BizTalk Server and today I work with Azure Integration Services. Along the way I've designed, built and deployed many integration solutions, on-premises, hybrid and in the cloud. I've always enjoyed sharing what I learn with peers, through blogging, writing books, editing for InfoQ, and speaking at user groups and conferences such as Integrate and NIS. Sharing knowledge comes back to you many times over: it has given me great opportunities, and above all many friends in the community. Looking back, what advice do you wish you had been given earlier that you'd now share with those looking to get into STEM/technology? Stay curious, and don't wait until you feel like an expert to share what you know. Writing a blog post, giving a talk at a local user group, or just asking questions in the community speeds up your learning enormously and connects you with people who will help you grow. Also, learn the fundamentals well. Technologies change; integration went from BizTalk to Logic Apps. But patterns, principles and how you approach a problem last a whole career. What has helped you grow professionally? Curiosity about how things work. I learn by trying things out and building demos, and I read a lot: books, blogs, documentation. Attending, and later speaking at, user groups and conferences has been just as important. So has staying close to Microsoft, locally and with the product groups in Redmond. The conversations with peers and product teams have taught me as much as any technology. If you had a magic wand that could create a feature in Logic Apps, what would it be and why? A seamless, browser-based development experience with native GitHub integration. The designer in the browser offers the best experience for building Logic Apps, better than VS Code. But today, getting a workflow into source control means exporting it, working locally, and then pushing it. I'd love to do it all in the browser: design the Logic App, commit it straight to the repository, and let a pipeline deploy it to the other environments. That would bring the ease of the designer and proper DevOps practices together. News from our product group Introducing the Logic Apps local CLI: develop Standard workflows from your terminal Microsoft has introduced a public preview Azure CLI extension for local Logic Apps Standard development. It supports project creation, connector discovery, connection configuration, runtime management, workflow validation, and execution diagnostics from the terminal. Developers can invoke commands directly, automate them in scripts, or let coding agents use them with approval. The extension complements the visual designer and existing Azure resource-management commands rather than replacing them. An accompanying Copilot skill guides schema discovery, authentication choices, validation, and execution checks, helping teams ground development and review in observable tool results instead of assumptions. Hybrid Logic Apps - SQL as storage provider benchmarking This benchmark examines SQL Server storage behavior under a file-triggered Hybrid Logic Apps workload in a disconnected, single-node OpenShift environment. SQL Server 2025, file storage, and the cluster share one Windows host and backing disk. Two thirty-minute tests recorded no failed runs; the one-hour dashboard showed 45,821 successful executions. SQL averaged 1.83% of host CPU capacity, while storage contention and tail latency remained important scaling considerations. The article recommends dedicated storage as volumes grow and capacity planning based on peak and tail measurements, stressing that these results describe one workload rather than a general capacity guarantee. 🆕Orchestrate Foundry Prompt and Hosted Agents with Logic Apps Automation Logic Apps Automation can orchestrate Microsoft Foundry Prompt Agents and Hosted Agents as steps in business workflows. API calls, schedules, and connector events can trigger agents, with deterministic actions gathering inputs and validating or acting on outputs. The article distinguishes configured Prompt Agents from container-based Hosted Agents that support custom code and orchestration. Logic Apps provides branching, retries, timeouts, parallel execution, and run history around agent calls. It also outlines a migration path ahead of Foundry workflows retiring on December 1, 2026, helping teams move interactive agents into traceable, event-driven business processes. From Form to Action: A Governed, Event-Driven AI Intake Pipeline with Azure Integration Services This reference architecture turns document-heavy permit intake into governed, asynchronous processing with Azure Integration Services and Microsoft Foundry. API Management controls entry and model access, while Logic Apps validates, enriches, and routes submissions to Service Bus. An Azure Function uses Document Intelligence and a Foundry model before writing a case record and publishing an Event Grid event. A shared correlation ID connects intake, processing, and downstream notifications. The article emphasizes durable hand-off, explicit failure handling, controlled model consumption, and traceability, with an accompanying repository that supports offline exploration without an Azure subscription. 💲Announcing Free Grant and Pricing for Logic Apps Automation Microsoft has announced pricing and free grants for Logic Apps Automation, currently in public preview. Monthly allowances per Azure subscription include 108,000 workflow execution-seconds, 1 GB of data retention, 1,000 Standard and 500 Enterprise managed connector calls, knowledge storage, and AI usage. One managed environment is free only for the first sixty days, unlike the recurring monthly usage grants. Usage beyond the included limits is billed separately. The article explains how teams can experiment and run initial automations within those allowances, then plan paid usage as business process and AI orchestration workloads grow. News from our community Logic Apps Community Day 2026: Agenda and Speakers Announced Event by Ahmed Bayoumy and Sebastian Meyer The agenda and speaker lineup for Logic Apps Community Day 2026 are now published, with the event taking place on December 3, 2026. This free, online community event will stream live on YouTube and is open to attendees worldwide. Eight talks combine longer sessions and lightning talks, covering AI and automation, enterprise architecture, production operations, scalability, and BizTalk migration. Q&A slots between talks provide opportunities to engage with the speakers. The official event page includes the full agenda, speaker details, and an option to add the event to a calendar. Don't Rebuild Your Workflows Inside Agents: Calling Azure Logic Apps from Microsoft Foundry, Securely Post by Rob McKenna Enterprise agents can reuse reviewed business processes rather than duplicate workflow logic inside prompts or agent code. This article demonstrates a Microsoft Foundry agent invoking a Logic Apps workflow through an OpenAPI tool, using managed identity and Entra authorization instead of SAS keys. A synthetic prior-authorization scenario combines a lookup, business-day calculation, escalation, and notification before returning a plain-language response. The approach keeps business rules in the existing workflow while separating conversational interaction from execution, providing a concrete pattern for securely exposing established integrations as agent tools. When Liquid transform in Logic Apps doesn't Behave like Liquid: A subtle string to integer pitfall Post by Şahin Özdemir Generating a date ten years ahead exposes a subtle type-conversion problem in Logic Apps Liquid transformations. The underlying DotLiquid implementation can treat a formatted year as a string, producing concatenation rather than the expected arithmetic result. Common integer-conversion techniques do not reliably resolve the issue. The article demonstrates converting through a floating-point value with the Times: 1.0 filter and applying Round before completing the calculation. This practical example helps integration developers distinguish Liquid syntax from runtime-specific behavior and avoid prolonged debugging of seemingly simple transformation logic. Logic Apps Standard brings freedom Post by Mikael Sand Choosing between Logic Apps Consumption and Standard involves more than comparing per-action charges with a fixed runtime cost. This article argues that Standard allows integration design to focus on business requirements rather than minimizing transactions, particularly when built-in operations process large volumes of records. It describes greater cost predictability within runtime capacity while acknowledging additional infrastructure ownership and networking complexity. Capacity, connectivity, DNS, routing, and firewall configuration remain operational responsibilities. The comparison helps teams weigh architectural flexibility against management overhead when treating integration as a strategic platform capability. Logic Apps and AI Agents: Building Agentic Workflows on Azure Integration Services Post by Mirko Peters Agentic integration design requires choosing an appropriate platform owner as well as connecting a model to business systems. This guide compares Logic Apps with Power Automate, distinguishing Azure resource management, managed identities, infrastructure templates, and monitoring from maker-oriented environments and governance. It explains agent workflow concepts and describes tools as named collections of actions with clear responsibilities. Model configuration and pricing vary by hosting plan, and some capabilities remain in preview. The discussion helps architects separate ownership, tool design, and runtime considerations before building AI-driven business processes. Microsoft Fabric and Logic Apps Side by Side Video by Sebastian Meyer Connecting real-time analytics to operational workflows allows detected business events to initiate action rather than remain dashboard observations. This video demonstrates combining Microsoft Fabric Real-Time Intelligence with business processes built in Logic Apps. The accompanying post describes events arriving from coffee stores and handing relevant information to the integration platform through the Logic Apps Automation SKU. The example separates event detection on the data platform from process execution on the integration platform, illustrating how teams can connect these responsibilities without treating analytics and business automation as unrelated systems. Getting Started Logic App Standard in Azure Video by Stephen W. Thomas Moving locally developed workflows into Azure requires a configured hosting environment as well as a deployment step. This fourteen-minute walkthrough demonstrates creating a Logic Apps Standard environment and deploying a local project from Visual Studio Code. It covers the Workflow Service Plan, storage, application settings, portal-based workflow creation, and connection-string management. The accompanying post also highlights removing the unused hosting plan during demo cleanup to stop further charges. The tutorial gives developers a practical sequence for taking local integration work into the cloud while considering configuration and resource lifecycle. Azure Logic Apps Automation: A New Approach to Dynamic, AI-Powered Business Process Automation Post by Manoj Sethuraman Business processes involving unstructured information, changing rules, and frequent exceptions can be difficult to express as fully predefined workflows. This article introduces Logic Apps Automation as an adaptive approach combining contextual AI decisions, organizational knowledge, human involvement, and enterprise integrations. It outlines project boundaries for governance and isolation, deployable applications containing process assets, and executable workflows combining triggers and actions. The comparison with traditional deterministic automation helps architects consider where runtime flexibility is useful while retaining explicit boundaries around deployment, oversight, and integration responsibilities across business functions. 📈 Daily Exchange Rates, Zero Manual Effort: D365FO + Logic Apps Post by Anitha Eswaran Daily exchange-rate imports can become repetitive and error-prone when an SFTP folder retains both historical and newly delivered files. This article describes a Logic Apps integration that identifies current-day files before submitting them to Dynamics 365 Finance and Operations through an enqueue-based approach. A scheduled workflow starts after the expected delivery time, lists files with the built-in SFTP connector, and evaluates metadata to filter processing. The example demonstrates how selection and validation steps reduce repeated historical imports and unnecessary work while automating a recurring finance integration requirement. What's New with Logic Apps Automation Post by Sagar Sharma The NIS 2026 updates connect Logic Apps Automation capabilities with practical environment and subscription planning. This recap covers managed AI models, reusable templates, development-platform connectors, and orchestration of Foundry and managed agents. It separates agent construction and governance from workflow triggering and business-system integration. Pricing combines a managed-environment base fee, compute that scales to zero, and optional capabilities, alongside free allowances. The article also distinguishes announced features from roadmap items, helping integration architects assess operational ownership, environment counts, and experimentation costs before designing an automation platform. Coders, What's new with Low Code Logic Apps? Post by Sagar Sharma Integration developers need local build, test, debug, and deployment loops that work with source control and coding agents. This NIS recap examines the Logic Apps Standard SDK, which expresses workflows through typed C# and a fluent API, allowing compiler feedback to catch mistakes earlier. It also discusses the local CLI lifecycle and Connector Namespace as managed connectivity for applications and agents. The article frames these capabilities as complementary developer surfaces, helping teams combine low-code orchestration with familiar software-engineering practices while checking release details before relying on illustrative commands. BizTalk End of Support: Logic Apps Migration Agent, Hybrid and Microsoft Migration Incentives Post by Sagar Sharma Planning a BizTalk migration requires more than waiting for the support deadline or converting individual artifacts. This article reviews lifecycle considerations and introduces the AI-assisted Logic Apps Migration Agent for assessing, planning, converting, validating, and deploying workloads to Standard. Three Copilot agents share a five-stage pipeline, with human approval between stages. The discussion also covers map reuse, hybrid deployment, and migration incentives. It positions tooling as an accelerator rather than a replacement for architectural judgment, helping teams structure discovery and validation around the dependencies and business behavior of an existing integration estate.334Views0likes0CommentsHybrid Logic Apps - SQL as storage provider benchmarking
Key findings for technical decision makers Hybrid Logic Apps ran a high-volume, file-driven integration workload on deliberately modest on-premises hardware: one host shared by the cluster, file storage and SQL Server 2025. Across both 30-minute tests there were no failed runs, and the one-hour dashboard view showed 45,821 successful runs at a 100% success rate. The database was not a cost driver: SQL Server used an average of 1.83% of host CPU capacity. Most runs finished in about 4 seconds, with a longer tail for the slowest 1%. The factor that most affects scale is storage, not server count, because adding workflow instances does not add disk capacity. For planning, budget for dedicated storage for the database and files as volumes grow, size capacity on peak and tail response times rather than averages, and validate with your own workloads. These results are a baseline for one workload, not a product-wide capacity guarantee. A practical look at throughput, latency, reads, writes, and locks The primary goal of this exercise is to evaluate SQL read and write behavior and the time spent waiting for locks under integration load. Workflow throughput supplies the workload context; it is not a substitute for those database measurements. This is a mixed-workload observation, not an isolated SQL capacity test. In a 30-minute baseline, files were offered to an Azure Logic Apps workflow at approximately 100 files per second. SQL CPU usage remained low, while a substantial file backlog accumulated. The lesson is not that one component is necessarily slow. It is that a useful benchmark must connect offered load, completed throughput, latency, and waiting rather than treating any one metric as the answer. The SQL comparison tells a different story from workflow throughput alone: average workflow-state data-file write I/O latency rose from 12.958 to 38.652 ms, while accumulated instance-wide lock waiting remained near 1,470 task-seconds. Faster workflow completion did not mean that every SQL measurement improved. A repeat of the same 30-minute workload subsequently showed 3.87% higher successful throughput, 6.40% lower p95 execution latency, and 8.68% lower p99 execution latency, with no failed workflow runs in either measured window. Both measurements are retained below: the repeat was an observed improvement, not proof of a tuning change or a product-wide performance guarantee. The workflow The workflow snapshot shows the processing sequence used in the benchmark. The workflow is taken such that huge set of I/O operations are performed during the workflow executions to simulate the SQL benchmarking under high I/O operations. The workflow performs six steps: Detect a newly created file in a receiving folder. Insert a business record into SQL. Read the source file's contents. Create a copy in a destination folder. Delete the source file. Delete the destination copy. This is a synthetic processing-and-cleanup scenario, not an archival workflow: both test-file copies are removed on successful completion. A successful run means that the complete sequence finished, not just that the SQL insert succeeded. Infrastructure: OpenShift K8se cluster with single node, one shared disk The deployment topology is a hosted Windows machine running an on-premises, single-node OpenShift cluster in a Linux VM, with local SMB storage and SQL Server 2025 on the same Windows host. The SMB files, SQL data and transaction logs, and cluster VM storage all share the same host drive and backing disk. Different folders or virtual disks on that shared backing disk do not create independent I/O capacity. The workflow operates in a fully disconnected runtime environment: the execution and data paths shown remain local, without an external runtime-service dependency for this workflow. This documents the supplied runtime topology, not an independent network-isolation test or a claim about offline installation and management. Autoscaling adds workflow pods, not OpenShift nodes or additional disks. The configured 1-10 replicas therefore share the same single-node compute and storage resources. This layout matters when interpreting performance. File creation, reads, copies, and deletion can overlap with SQL reads, data writes, transaction-log writes, and cluster storage activity on the same disk. More pods can increase that shared I/O demand without increasing disk capacity. Storage delays can also lengthen transactions and the time locks remain held, but the topology alone does not establish that disk contention caused the measured blocking or throughput limit. How the baseline was measured The test offered small, 1 KiB files at a target rate of 100 files per second for 30 minutes. The existing workflow and database configuration were retained during the measurement; this was a baseline, not a tuned result. Measurements covered file publication, workflow starts and outcomes, execution duration, SQL request timing, SQL process resources, database-file I/O, and blocking. Existing autoscaling remained enabled, so this was not a fixed-replica benchmark. Observability also has a cost: these are instrumented results, not a claim of zero measurement overhead. SQL benchmark: reads, writes, and locking periods The database results below come from the two measured 30-minute exercises, not from the one-hour dashboard view later in this post. SQL counter snapshots bracket each exercise: approximately 1,801.16 seconds for the initial workflow-state observation and 1,801.74 seconds for the repeat. Business-data counter coverage is approximately 1,801.16 and 1,801.71 seconds. The workflow load-generation window itself is exactly 1,800 seconds. Evaluation Plain-language question What the saved measurements can answer Read How much information does SQL retrieve, and how long do disk reads take? Physical database-file read counts and average I/O latency; completed SQL request timing. Write How much information does SQL save, and how long do data and log writes take? Physical data-file and log-file write counts and average I/O latency; completed SQL request timing. Locking period How long does an operation wait for another operation, and how long does the owner hold its lock? Accumulated lock-wait time, waiting-task counts, and sampled blocking. Individual lock-hold durations were not recorded. Read and write I/O: volume and latency The two database roles are labeled workflow state and business data. Each row below describes a file-I/O operation, not an individual SQL statement. Database role / file I/O operation Initial count Repeat count Initial average ms/I/O Repeat average ms/I/O Workflow state / data Read 35,169 9,331 0.896 0.571 Workflow state / data Write 74,146 90,913 12.958 38.652 Workflow state / log Write 318,134 334,775 0.938 1.115 Business data / data Read 104 19 0.923 0.474 Business data / data Write 124 14 0.919 0.714 Business data / log Write 25,826 27,018 1.152 1.425 Average read I/O latency = read-stall milliseconds / read I/O count. Average write I/O latency = write-stall milliseconds / write I/O count. These are operation-weighted counter ratios, not averages of sample averages. The repeat performed fewer physical data reads and more workflow-state writes. Its average workflow-state data-file write latency was approximately three times the initial value. Workflow-state log writes also became slower on average. The small business-data file-I/O counts should not be treated as a stable disk-performance estimate. A read satisfied from memory need not cause a physical file read. Likewise, many row changes can be persisted together, and transaction-log writes are distinct from later data-page writes. Consequently, these counts are not SELECT counts, INSERT counts, or committed business-record counts. None of the file-I/O averages is the duration of an entire SQL statement or transaction. Completed SQL request timing SQL requests provide a separate view of elapsed server-side work. The trace selected events completed within each exact 30-minute window. Percentiles are approximate; requests still running at cutoff are excluded. Database role / request type Window Completed events Average ms p95 ms p99 ms Workflow state / remote call Initial 1,127,136 1.780 2.431 62.479 Workflow state / remote call Repeat 1,170,736 1.647 1.643 52.385 Business data / remote call Initial 81,114 0.960 1.354 14.487 Business data / remote call Repeat 84,220 1.041 1.225 15.503 Workflow state / SQL batch Initial 586 0.244 0.382 0.557 Workflow state / SQL batch Repeat 645 101.029 33.750 7,967.948 A remote call is a completed RPC event, not necessarily one statement. These request populations mix reads, writes, and supporting work; they do not establish separate SELECT-only or INSERT-only latency distributions. Batch events are shown separately rather than hidden inside the much larger remote-call population. Database-wide activity can include monitoring and dashboard requests, so this is not an application-only isolation test. The repeat improved workflow-state remote-call latency, but business-data p99 and batch latency worsened. There is no basis for saying that all SQL latency improved. Lock waiting: duration, concurrency, and observation period A lock hold belongs to the operation owning the lock: acquisition through release. A lock wait belongs to another operation waiting to obtain a conflicting lock. These are different periods; a waiting operation's duration does not reveal precisely how long the owner held the lock. Locking measurement Scope Initial Repeat Accumulated lock-wait time SQL instance 1,473.235 s 1,467.470 s Lock-waiting task count SQL instance 51,283 50,548 Wait-time / waiting-task counter ratio SQL instance 28.728 ms 29.031 ms Range/update coordination waits SQL instance 1,287.958 s 1,273.562 s Update coordination waits SQL instance 183.449 s 168.197 s Other lock waits SQL instance 1.828 s 25.711 s Peak sampled blocked requests Workflow-state database 16 20 Snapshots showing blocked requests Workflow-state database 85 / 353 78 / 354 Longest span of consecutive positive blocking snapshots Workflow-state database Approximately 15.2 s Approximately 10.2 s The cumulative lock counters are instance-wide and reported once, not added again for each database. Other activity on the instance can contribute. They count waiting SQL tasks, not unique transactions, locks, or workflow runs. The mean counter ratio is not a measured per-lock hold time or a lock-wait percentile. 1,473 accumulated wait-seconds does not mean the database was continuously blocked for 1,473 seconds. Concurrent tasks can wait at the same time. The totals cannot be divided by test duration and described as the percentage of the test spent blocked. The roughly five-second snapshots count requests blocked by another identified session. They do not record each request's wait type or lock lifetime. The longest positive-snapshot span means blocking was present at successive observations; different requests may have been involved, and blocking could have stopped between samples. It is not proof of one continuous blocking episode or one transaction holding a lock for that long. No blocked business-data requests were seen in the snapshots; brief blocking between samples remains possible. For write-related context, instance-wide waiting for transaction-log flushes accumulated 1,200.092 seconds initially and 1,390.289 seconds in the repeat. These are task-wait sums, not individual commit latency or additional time to add to workflow duration. What this does and does not establish The exercise establishes measured read/write I/O volume and average latency, mixed SQL request timing, and aggregate lock waiting with sampled blocking under the workflow workload. It does not establish isolated SQL read/write capacity, statement-specific read/write latency, exact blocking-episode lengths, or p50/p95/p99 lock-hold durations. One-hour dashboard results (Initial + repeat) These are actual values from the supplied dashboard with Last 1 hour visibly selected. This is a rolling dashboard observation, not a newly executed one-hour controlled load test. Measurement Dashboard result Selected observation period Last 1 hour Total runs displayed 45,821 Successful runs displayed 45,821 Failed runs displayed 0 Displayed successful count / 3,600 seconds 12.728 runs/second Average execution duration displayed 3.70 seconds Success rate displayed 100% Retry count No data Processing beyond the cutoff This supplied dashboard view spans a longer period than the 30-minute baseline. Processing continues after file generation stops. The displayed run total belongs to the dashboard's selected scope and aggregation. It is not the number of successful completions during the fixed measurement window, and it has not been reconciled to the exact benchmark cohort. The curve shows run counts over time, not a cumulative completion counter; its bucket size is not specified here, so the vertical values should not be read as runs per second. Latency: look beyond the average Successful workflow execution duration Result Average 4.11 seconds p50 Approximately 3.89 seconds p95 Approximately 6.20 seconds p99 Approximately 13.01 seconds Maximum 23.71 seconds These durations measure workflow execution after a run starts. They exclude time spent waiting in the receiving folder. As the backlog grows, a file's arrival-to-completion time can be much longer. Each point summarizes one minute. Workflow duration uses seconds; SQL request duration uses milliseconds. The SQL panels separate requests associated with workflow state from requests associated with business data, without exposing database identities. The first few minutes show higher workflow latency than much of the later window. The chart exposes this change but does not, by itself, establish its cause. The workflow chart includes successful runs completed by cutoff. SQL timing includes captured completed requests; requests still running at cutoff are not represented in those percentiles. Workflow bucket and whole-window comparison percentiles were computed from the observed completed runs; displayed values are rounded. SQL percentiles are approximate. SQL activity in the broader observation period These supplied SQL panels provide broader context, not additional fixed-window baseline results. SQL operations per second counts database work, not completed workflow runs: one workflow can require multiple SQL operations. The CPU line here is measured in milliseconds of SQL execution CPU time, not the percentage of host capacity shown below. Dashboard time ranges and aggregation differ from the baseline charts, so their averages and totals should not be substituted for the 30-minute measurements. SQL process measurement Result Average CPU, normalized to host capacity 1.83% Peak sampled CPU, normalized to host capacity 8.08% Physical memory at the first recorded sample Approximately 1.20 GiB Physical memory at the last recorded sample and peak Approximately 3.15 GiB These are instance-wide SQL process measurements, not workflow-container utilization or total machine utilization. CPU points represent roughly five-second interval averages, not instantaneous peaks. The dashed reference uses the reported full-window average; the recorded series ends slightly before cutoff and is not extrapolated. A system can have CPU headroom while work waits for storage, another transaction, a network response, or another part of the workflow. Aggregate CPU usage can also hide a narrower, serialized bottleneck. Configured scaling and application resources The deployment's configured scaling values were captured after the repeat. Application-configuration fingerprints matched before and after the test. Scaling setting Captured value Minimum replicas 1 Maximum replicas 10 Polling interval 30 seconds Configured cooldown 300 seconds Polling and cooldown values describe configuration, not guaranteed reaction times. Actual scaling also depends on controller decisions and stabilization. The dashboard's matching-pod count rises from about one to five, then steps down through four to three during the repeat. A later increase occurs after the measurement cutoff, while queued work continues processing. This panel counts matching pod records; it does not filter explicitly for readiness. It should not be interpreted as proof that every displayed pod was ready at every instant. Independent runtime checks found one ready replica before the repeat and three after it. The captured resource budget also distinguishes the application container from the entire pod: Resource scope, per replica CPU request CPU limit Memory request Memory limit Application container 0.425 cores 1 core 1,844 MiB 2 GiB Whole pod, including supporting containers 0.501 cores 1.5 cores 2 GiB 4.5 GiB Green represents usage; yellow represents the summed application-container limits. The chart's resource scope excludes supporting containers, so it is not the whole-pod or cluster resource budget. The CPU usage line is a five-minute rate expressed in cores. Memory usage is the containers' working set. As the number of matching application containers changes, their summed limits change too; this does not mean usage suddenly rose to the limit. These application metrics are not interchangeable with SQL process CPU percentages or SQL process physical memory. Aggregate headroom also does not exclude per-container throttling or uneven load distribution. Supplied latency dashboard This supplied panel shows p50 3.60 s, p95 5.47 s, and p99 10.5 s for its selected scope. Its time filter is not visible, so these values are not substituted for the fixed-window comparison above. Run and SQL trends beyond the repeat window This view extends beyond the 20:54:59 IST measurement cutoff and includes continued processing. Values are counts in the dashboard's time buckets, not a cumulative total or a documented runs-per-second rate. SQL duration and SQL CPU time here are in milliseconds. They are not workflow execution time or host CPU percentage. The dashboard aggregation covers a different scope from the verified 30-minute SQL measurements. How to use these results This is a baseline for one synthetic workflow, payload size, workload shape, and deployment. It is not a product-wide capacity limit, service-level guarantee, or comparison between deployment platforms. Workflow outcomes describe runs started within the measurement window and their status at cutoff. They are time-window totals, not a file-by-file correlation audit; concurrent executions of the same workflow can contribute. SQL process resources and wait measurements can include other activity on the same instance; individual SQL requests are not equivalent to workflow runs. For organizations that must keep integrations close to their data, whether for regulatory, data-residency or operational reasons, Hybrid Logic Apps brings the Logic Apps platform into their own datacenter. In this benchmark, the workflow ran fully disconnected on a single on-premises host, with SQL Server 2025 storing workflow state and no dependency on an external runtime service. The business value is straightforward. Sensitive data stays on site, workflow state lives in a database your team already operates and protects, capacity scales automatically within the hardware you own, and when demand spikes, work queues instead of failing. Teams also build on the same Logic Apps skills they use in Azure, rather than maintaining a separate integration stack for on-premises workloads. Recommendations Do not manually alter, truncate, drop, or selectively delete records from runtime-managed SQL tables. Partial changes can leave missing content, orphaned metadata, inconsistent run history, or state that affects retries and recovery. Use the deployment’s supported retention and cleanup mechanisms; any exceptional database maintenance should follow with a recoverable backup. Performance: Evaluate storage latency, CPU, memory, and blocking. Validate supported configuration changes through repeatable benchmarks rather than modifying internal tables or weakening transaction consistency. Please refer this for SQL server guidance Monitor and Tune for Performance - SQL Server | Microsoft Learn Give SQL independent I/O capacity from SMB and cluster VM storage. Increase CPU or memory when measurements justify it—not simply because throughput is low. Use supported availability groups or failover clustering for availability and recovery. These are not automatically a scale-out solution for writes. Follow Availability Group: Prerequisites, Restrictions, and Recommendations - SQL Server Always On | Microsoft Learn We executed the test using single node K8se cluster, for better use distribute workflow pods across independent worker hosts with adequate storage and networking. Scale incrementally and remeasure successful throughput, write latency, blocking, backlog, and recovery behavior while preserving runtime-managed tables.274Views0likes0CommentsModernize Any Integration Platform to Azure Logic Apps Standard with the Logic Apps Migration Agent
Explore the open-source Logic Apps Migration Agent Enterprise integration is entering a new era Enterprise integration platforms have powered business-critical processes for decades. They connect applications, data, partners, devices, and industries, often carrying transactions that an organization cannot afford to interrupt. Expectations have changed. Organizations want cloud-native architectures, AI-assisted automation, stronger governance, improved developer productivity, and faster response to business change. Yet many integration estates contain years of accumulated dependencies, custom code, transformations, operational procedures, and platform-specific knowledge. The challenge is not simply moving an orchestration or flow from one runtime to another. This is not lift and shift. It is a refactoring exercise that preserves business intent and expected behavior while translating source-platform constructs into cloud-ready workflows, connectors, code, operational patterns, and deployment practices for Azure Logic Apps Standard. That is why we created the Logic Apps Migration Agent. Introducing the Logic Apps Migration Agent: An Open-source project to provide an AI End-to-End Modernization Experience The Logic Apps Migration Agent is an open-source Visual Studio Code extension that provides an AI-assisted, end-to-end modernization experience. It uses GitHub Copilot and the Visual Studio Code Language Model API to guide teams through a structured five-stage workflow, while keeping people in control at every stage. Rather than treating modernization as a single conversion step, the agent helps teams discover what they have, understand dependencies, design an appropriate target, generate baseline implementation artifacts, validate expected behavior, and prepare the solution for deployment to Azure Logic Apps Standard. Refactor the implementation, preserve the business intent Lift and shift attempts to reproduce the source platform as closely as possible in a new environment. That approach can carry forward legacy topology, operational assumptions, platform-specific patterns, and technical debt. The Migration Agent supports a different outcome. It uses the source implementation as evidence of the required business behavior, then helps teams design and generate an appropriate Logic Apps Standard implementation. Some components may map directly, while others require restructuring, consolidation, decomposition, replacement, or custom implementation. The objective is functional and semantic continuity, not structural duplication. A successful migration should preserve contracts, transformations, routing rules, ordering requirements, error behavior, and essential business outcomes while allowing the target solution to adopt Azure-native identity, connectivity, observability, resiliency, deployment, and operating practices. Preserve what the integration must do. Refactor how it does it. Start by understanding what you have For many organizations, discovery is one of the most difficult parts of modernization. Documentation may be incomplete, original developers may no longer be available, and relationships between applications, endpoints, schemas, maps, pipelines, and custom components may be difficult to reconstruct. The Migration Agent scans the source project, catalogs supported artifacts, organizes related components into flow groups, and identifies dependencies and migration gaps. It can also generate architecture and message-flow visualizations for review before conversion begins. This discovery output becomes the foundation for migration sequencing, refactoring decisions, effort discussions, and risk management. Use AI to accelerate the work, not remove accountability The Migration Agent uses specialized GitHub Copilot agents for analysis, planning, and conversion. AI helps interpret source artifacts, propose mappings, create task plans, and generate baseline Logic Apps artifacts. Enterprise integration, however, requires more than plausible code generation. Human-in-the-loop checkpoints let teams review discovered flows, resolve missing dependencies, reshape the proposed architecture, approve conversion plans, and validate generated behavior before progressing. This combines the speed of AI assistance with the governance and technical review required for mission-critical integration. Modernize incrementally and reduce migration risk Large integration estates do not need a single big-bang program. The Migration Agent organizes work into logical flow groups so teams can refactor one business capability or integration path at a time. Prioritize workloads by business value, risk, complexity, or platform urgency. Validate target architecture and operating patterns with a representative first migration. Run phased cutovers and coexistence strategies when required. Apply reusable refactoring patterns, templates, and engineering standards to subsequent waves. A phased approach helps teams build experience with Azure Logic Apps while reducing migration risk and preserving delivery momentum. Bring your own tests and validate continuously Migration confidence depends on behavior, not structural similarity. The agent supports validation using source specifications, sample files, test cases, and customer-provided black-box tests. This helps compare expected inputs and outputs and identify semantic differences earlier. Generated artifacts are a baseline. Domain-specific transformations, error-handling behavior, performance characteristics, security controls, and edge cases still require customer and partner expertise. Built for BizTalk today and extensible for other platforms BizTalk Server 2016 and BizTalk Server 2020 are the first fully implemented source platforms. MuleSoft Anypoint support is represented as an in-progress built-in parser. The architecture is open and extensible so contributors can add parsers and platform-specific migration capabilities for other integration technologies. That extensibility is central to the vision. A common modernization workflow can help teams apply consistent governance, target patterns, refactoring practices, and validation across mixed integration estates. Why Azure Logic Apps Standard? Azure Logic Apps Standard provides a modern destination with a local project structure, Visual Studio Code development experience, source-control alignment, CI/CD support, stateful and stateless workflows, enterprise connectivity, and Azure and hybrid deployment options. Modernization is not about reproducing a legacy topology component by component. The target design should be optimized for Logic Apps Standard rather than constrained by the source architecture. The migration preserves valuable business logic while refactoring the implementation around modern practices for identity, networking, observability, reliability, deployment, and operations. What your team should still own The Migration Agent accelerates repeatable work, but it does not replace the decisions that define a production-ready integration platform. Responsibility Refactoring focus Target architecture Refactor application and workflow boundaries for Logic Apps Standard. Select reliability, networking, deployment, and supporting Azure patterns rather than copying the source topology. Semantic equivalence Validate contracts, mappings, transformations, business rules, error behavior, ordering, retries, and edge cases. Capability gaps Redesign source capabilities without direct equivalents using connectors, custom code, local functions, API Management, Service Bus, or other appropriate Azure patterns. Production hardening Implement identity, secrets management, security policies, monitoring, cost controls, performance testing, resiliency, and operational ownership. Cutover and coexistence Plan backlog reconciliation, dual-run periods, data consistency, partner coordination, rollback, and decommissioning. More mission critical features for Logic Apps Standard and Hybrid We are weeks away from shipping the following features, aimed at any customers in the Enterprise Application Integration space: HL7 In-App operations in general availability. MLLP Receive/Send In-App connector in Public Preview. Rules Engine In-App operation for XML facts in Public Preview. MSMQ In-App connector in Public Preview. Oracle DB In-App connector in Public Preview. Flat File generation In-App operations in Public Preview. Integration accounts support (Hybrid On premises). NMS In-App connector in Public Preview. Improvements to our EDI capabilities. BizTalk Mapper to Data Mapper Migration path What about other integration platforms? Yes—the Logic Apps Migration Agent is designed to be customizable so you can migrate from any integration platform to Logic Apps (not just BizTalk). The open architecture lets you plug in new discovery, analysis, and conversion skills for the source product you’re modernizing, while keeping the same stage-gated workflow and human-in-the-loop checkpoints. We provide guidance and examples to help you extend the agent for other platforms than BizTalk —so you can tailor mappings, transformation rules, and validation to your customer’s standards and target patterns in Logic Apps. Benefits Faster time to value with a guided process: A structured discovery→planning→conversion workflow reduces uncertainty and helps teams move from assessment to execution with clear checkpoints. Higher confidence migrations: Human-in-the-loop validation, artifacts generation, and black-box testing support mission‑critical correctness and governance. Customizable for your source platform and standards: Extend the agent with product-specific discovery and conversion steps, tailor mappings and transformation rules, and align outputs with your target Logic Apps patterns and engineering conventions. Open-source transparency and control: Review how the tool works end-to-end, validate what it produces, and adopt changes at your pace without waiting for a closed release cycle. Community-driven innovation: Benefit from contributions across Microsoft, partners, and customers—new adapters, mapping packs, and best practices can be shared and reused. Lower total migration cost: Automating repeatable tasks reduces manual effort while preserving the ability to invest partner expertise where it matters most (architecture, governance, reliability, and operations). Reusable accelerators for partners: Partners can create differentiated offerings by packaging templates, validation suites, CI/CD pipelines, and domain-specific patterns on top of the agent. An accelerator for customers and partners For customers, the Migration Agent provides a practical starting point and a consistent process for moving from assessment to a refactored implementation. For professional services organizations and system integrators, the agent augments delivery rather than replacing it. Automating inventory, analysis, baseline generation, and validation scaffolding allows experts to focus on architecture, governance, security, reliability, domain-specific transformation, DevOps, performance, cutover, and operating-model change. Because the project is open source, partners can contribute parsers or package reusable templates, mapping packs, test suites, CI/CD assets, and industry-specific modernization patterns. Review our public documentation here: https://learn.microsoft.com/en-us/azure/logic-apps/migration/migration-agent-overview How to get started Download VSCode and install the Logic Apps Migration Agent extension. Organize source projects and dependencies in a clear directory structure. Include project files, bindings, schemas, maps, pipelines, orchestrations, custom code, configuration, certificates or certificate references, and available documentation. Once you have all your artifacts ready, point the Migration Agent to the directory with all the artifacts. Review every migration stage. Confirm the discovered architecture, resolve missing dependencies, and refine the target design before authorizing conversion. Prepare a representative test environment. The workstation running Visual Studio Code must be able to reach the systems needed for local or end-to-end validation. Bring known inputs, expected outputs, specifications, and existing test cases whenever possible. These materials improve validation and reduce ambiguity. Treat the first migration as a reusable foundation. Capture architecture patterns, naming standards, deployment templates, observability practices, and lessons that can accelerate subsequent waves. Use Claude Opus 4.8 or higher. Make sure you increase the Maximum number of requests for the Copilot Chat as follows (we recommend changing the value from 60 to 1000) Check the following video for a demonstration on how the Agent works and let us know if you have any questions in the comments.2.7KViews2likes1Comment💲Announcing Free Grant and Pricing for Logic Apps Automation
Today, we're announcing pricing for Azure Logic Apps Automation, now in public preview, along with monthly free grants that make it easier to start building, experimenting, and bringing automations to life. Logic Apps Automation is Azure's fully managed platform for business process automation and orchestration, including AI-powered automation. It's built for every builder with an automation problem, not just developers, and the free grants make it easy to go from idea to a working automation without a purchase decision up front. The free grant covers one managed environment per subscription and includes usage across key Logic Apps Automation capabilities, so you can start with your first use case, experiment with AI-powered automation, and run workloads in production within the included limits; then move to paid usage as your needs grow. Start today @ https://auto.azure.com/ Start free with monthly grants Every Azure subscription gets a monthly free grant across the platform. The only exception is Managed Environment which is a one-time free grant for first 60 days. When the usage stays within these limits you pay nothing. When it goes beyond these limits, you pay only for the additional usage. Usage Component Monthly free grant (per subscription) Core Platform Managed environment One environment, free for the first 60 days (2 months) Core Platform Workflow runtime 108,000 execution-seconds (about 30 hours) Core Platform Data retention 1 GB Optional Capabilities Managed connector calls 1,000 Standard + 500 Enterprise Optional Capabilities Knowledge storage 1 GB Optional Capabilities AI usage 1,100 AACs Optional Capabilities Isolated code execution 18,000 seconds (about 5 hours) What this means in practice Explore the platform, not a trimmed-down experience. The grants include workflow runtime, AI usage, knowledge, connectors, and sandboxed code, so you can explore every capability from day one. Build and iterate without watching the meter. With approximately 30 hours of execution time included each month, you can author, test, and run workflows as you build out your automation. Scale into paid usage as your needs grow. Grants reset every month, and you pay only for usage beyond them. Simple, usage-based pricing Beyond the included grants, Logic Apps Automation uses a pay-as-you-go pricing model across the capabilities your automations use. Billing has two parts: Core Platform: the managed environment, workflow runtime, and run-history retention that provide the foundation for your automations. Optional Capabilities: AI usage, knowledge storage, isolated code execution via sandbox and managed connectors, billed only when your workflows use them. For rates, regional pricing, and a worked monthly cost example, see Azure Logic Apps Automation pricing. How does the free grant works The free grant applies to the first environment you create in a subscription. Look for the Free tag next to an environment's name to see which is the free one Free environment period: The managed environment is free for 60 days, starting from the time you create it. Existing customers: If you already use Logic Apps Automation, create a new environment to use the free grant. The first new environment you create in your subscription receives it. Track your usage: In your environment, go to Settings and select the Free Grants tab to see your monthly limits and how much you've used. Important: Free grants are tied to the free environment. If you delete your free environment, you lose the ability to use the free grants, and you can't get them back by creating a new environment. Availability Logic Apps Automation is in public preview in Australia East, East Asia, North Central US, Southeast Asia, Sweden Central, UK South, and West US. Preview pricing and availability may change before general availability. Get started If you already have an Azure subscription, your included grants are available to help you start building today. Create your first Automation project, start from a template or with the AI workflow assistant, and explore what you can build with Logic Apps Automation. Get started with Logic Apps Automation Quickstart: build your first workflow Read the full pricing details MS Learn documentation Watch the Logic Apps Automation video series Share feedback or request a feature, or just let us know what you build with Automation!768Views0likes0Comments