In this issue:
Ace Aviator of the Month
April 2026's Ace Aviator: Marcelo Gomes
Marcelo Gomes - Integration Team Leader @ COFCO International
What’s your role and title? What are your responsibilities?
I’m an Integration Team Leader (Azure Integrations) at COFCO International, working within the Enterprise Integration Platform.
My core responsibility is to design, architect, and operate integration solutions that connect multiple enterprise systems in a scalable, secure, and resilient way. I sit at the intersection of business, architecture, and engineering, ensuring that business requirements are correctly translated into technical workflows and integration patterns.
From a practical standpoint, my responsibilities include:
- Defining integration architecture standards and patterns across the organization
- Designing end‑to‑end integration solutions using Azure Integration Services
- Owning and evolving the API landscape (via Azure API Management)
- Leading, mentoring, and supporting the integration team
- Driving PoCs, experiments, and technical explorations to validate new approaches
- Acting as a bridge between systems, teams, and business domains, ensuring alignment and clarity
In short, my role is to make sure integrations are not just working — but are well‑designed, maintainable, and aligned with business goals.
Can you give us some insights into your day‑to‑day activities and what a typical day looks like?
My day‑to‑day work is a balance between technical leadership, architecture, and execution.
A typical day usually involves:
- Working closely with Business Analysts and Product Owners to understand integration requirements, constraints, and expected outcomes
- Translating those requirements into integration flows, APIs, and orchestration logic
- Defining or validating the architecture of integrations, including patterns, error handling, resiliency, and observability
- Guiding developers during implementation, reviewing approaches, and helping them make architectural or design decisions
- Managing and governing APIs through Azure API Management, ensuring consistency, security, and reusability
- Unblocking team members by resolving technical issues, dependencies, or architectural doubts
- Performing estimations, supporting planning, and aligning delivery expectations
I’m also hands‑on. I actively build integrations myself — not just to help deliver, but to stay close to the platform, understand real challenges, and continuously improve our standards and practices. I strongly believe technical leadership requires staying connected to the actual implementation.
What motivates and inspires you to be an active member of the Aviators / Microsoft community?
What motivates me is knowledge sharing.
A big part of what I know today comes from content shared by others — blog posts, samples, talks, community discussions, and real‑world experiences. Most of my learning followed a simple loop:
someone shared → I tried it → I broke it → I fixed it → I learned.
For me, learning only really completes its cycle when we share back. Explaining what worked (and what didn’t) helps others avoid the same mistakes and accelerates collective growth.
Communities like Aviators and the Microsoft ecosystem create a space where learning is practical, honest, and experience‑driven — and that’s exactly the type of environment I want to contribute to.
Looking back, what advice would you give to people getting into STEM or technology?
My main advice is: start by doing.
Don’t wait until you feel ready or confident — you won’t. When you start doing, you will fail. And that failure is not a problem; it’s part of the learning process. Each failure builds experience, confidence, and technical maturity.
Another important point: ask questions.
There is no such thing as a stupid question. Asking questions opens perspectives, challenges assumptions, and often triggers better solutions. Sometimes, a simple question from a fresh point of view can completely change how a problem is solved.
Progress in technology comes from curiosity, iteration, and collaboration — not perfection.
What has helped you grow professionally?
Curiosity has been the biggest driver of my professional growth.
I like to understand how things work under the hood, not just how to use them. When I’m curious about something, I try it myself, test different approaches, and build my own experience around it.
That hands‑on curiosity helps me:
- Develop stronger technical intuition
- Understand trade‑offs instead of just following patterns blindly
- Make better architectural decisions
- Communicate more clearly with both technical and non‑technical stakeholders
Having personal experience with successes and failures gives me clarity about what I’m really looking for in a solution — and that has been key to my growth.
If you had a magic wand to create a new feature in Logic Apps, what would it be and why?
I’d add real‑time debugging with execution control.
Specifically, the ability to:
- Pause a running Logic App execution
- Inspect intermediate states, variables, and payloads in real time
- Step through actions one by one, similar to a traditional debugger
This would dramatically improve troubleshooting, learning, and optimization, especially in complex orchestrations. Today, we rely heavily on post‑execution inspection, which works — but real‑time visibility would be a huge leap forward in productivity and understanding.
For integration engineers, that kind of feature would be a true game‑changer.
News from our product group
How to revoke connection OAuth programmatically in Logic Apps
The post shows how to revoke an API connection’s OAuth tokens programmatically in Logic Apps, without using the portal. It covers two approaches: invoking the Revoke Connection Keys REST API directly from a Logic App using the 'Invoke an HTTP request' action, and using an Azure AD app registration to acquire a bearer token that authorizes the revoke call from Logic Apps or tools like Postman. Step-by-step guidance includes building the request URL, obtaining tokens with client credentials, parsing the token response, and setting the Authorization header. It also documents required permissions and a least-privilege custom RBAC role.
Introducing Skills in Azure API Center
This article introduces Skills in Azure API Center—registered, reusable capabilities that AI agents can discover and use alongside APIs, models, agents, and MCP servers. A skill describes what it does, its source repository, ownership, and which tools it is allowed to access, providing explicit governance. Teams can register skills manually in the Azure portal or automatically sync them from a Git repository, supporting GitOps workflows at scale. The portal offers discovery, filtering, and lifecycle visibility. Benefits include a single inventory for AI assets, better reuse, and controlled access via Allowed tools. Skills are available in preview with documentation links.
Reliable blob processing using Azure Logic Apps: Recommended architecture
The post explains limitations of the in‑app Azure Blob trigger in Logic Apps, which relies on polling and best‑effort storage logs that can miss events under load. For mission‑critical scenarios, it recommends a queue‑based pattern: have the source system emit a message to Azure Storage Queues after each blob upload, then trigger the Logic App from the queue and fetch the blob by metadata. Benefits include guaranteed triggering, decoupling, retries, and observability. As an alternative, it outlines using Event Grid with single‑tenant Logic App endpoints, plus caveats for private endpoints and subscription validation requirements.
Implementing / Migrating the BizTalk Server Aggregator Pattern to Azure Logic Apps Standard
This article shows how to implement or migrate the classic BizTalk Server Aggregator pattern to Azure Logic Apps Standard using a production-ready template available in the Azure portal. It maps BizTalk orchestration concepts (correlation sets, pipelines, MessageBox) to cloud-native equivalents: a stateful workflow, Azure Service Bus as the messaging backbone, CorrelationId-based grouping, and FlatFileDecoding for reusing existing BizTalk XSD schemas with zero refactoring. Step-by-step guidance covers triggering with the Service Bus connector, grouping messages by CorrelationId, decoding flat files, composing aggregated results, and delivering them via HTTP. A side‑by‑side comparison highlights architectural differences and migration considerations, aligned with BizTalk Server end‑of‑life timelines.
News from our community
Resilience for Azure IPaaS services
Post by Stéphane Eyskens
Stéphane Eyskens examines resilience patterns for Azure iPaaS workloads and how to design multi‑region architectures spanning stateless and stateful services. The article maps strategies across Service Bus, Event Hubs, Event Grid, Durable Functions, Logic Apps, and API Management, highlighting failover models, idempotency, partitioning, and retry considerations. It discusses trade‑offs between active‑active and active‑passive, the role of a governed API front door, and the importance of consistent telemetry for recovery and diagnostics. The piece offers pragmatic guidance for integration teams building high‑availability, fault‑tolerant solutions on Azure.
From APIs to Agents: Rethinking Integration in the Agentic Era
Post by Al Ghoniem, MBA
This article frames AI agents as a new layer in enterprise integration rather than a replacement for existing platforms. It contrasts deterministic orchestration with agent‑mediated behavior, then proposes an Azure‑aligned architecture: Azure AI Agent Service as runtime, API Management as the governed tool gateway, Service Bus/Event Grid for events, Logic Apps for deterministic workflows, API Center as registry, and Entra for identity and control. It also outlines patterns—tool‑mediated access, hybrid orchestration, event+agent systems, and policy‑enforced interaction—plus anti‑patterns to avoid.
DevUP Talks 01 - 2026 Q1 trends with Kent Weare
Video by Mattias Lögdberg
Mattias Lögdberg hosts Kent Weare for a concise discussion on early‑2026 trends affecting integration and cloud development. The conversation explores how AI is reshaping solution design, where new opportunities are emerging, and how teams can adapt practices for reliability, scalability, and speed. It emphasizes practical implications for developers and architects working with Azure services and modern integration stacks. The episode serves as a quick way to track directional changes and focus on skills that matter as agentic automation and platform capabilities evolve.
Azure Logic Apps as MCP Servers: A Step-by-Step Guide
Post by Stephen W Thomas
Stephen W Thomas shows how to expose Azure Logic Apps (Standard) as MCP servers so AI agents can safely reuse existing enterprise workflows. The guide explains why this matters—reusing logic, tapping 1,400+ connectors, and applying key-based auth—and walks through creating an HTTP workflow, defining JSON schemas, connecting to SQL Server, and generating API keys from the MCP Servers blade. It closes with testing in VS Code, demonstrating how agents invoke Logic Apps tools to query live data with governance intact, without rewriting integration code.
BizTalk to Azure Migration Roadmap: Integration Journey
Post by Sandro Pereira
This roadmap-style article distills lessons from BizTalk-to-Azure migrations into a structured journey. It outlines motivations for moving, capability mapping from BizTalk to Azure Integration Services, and phased strategies that reduce risk while modernizing. Readers get guidance on assessing dependencies, choosing target Azure services, designing hybrid or cloud‑native architectures, and sequencing workloads. The post emphasises that migration is not a lift‑and‑shift but a program of work aligned to business priorities, platform governance, and operational readiness.
BizTalk Adapters to Azure Logic Apps Connectors
Post by Michael Stephenson
Michael Stephenson discusses how organizations migrating from BizTalk must rethink integration patterns when moving to Azure Logic Apps connectors. The post considers what maps well, where gaps and edge cases appear, and how real-world implementations often require re‑architecting around AIS capabilities rather than a one‑to‑one adapter swap. It highlights community perspectives and practical considerations for planning, governance, and operationalizing new designs beyond pure connector parity.
Pro-Code Enterprise AI-Agents using MCP for Low-Code Integration
Video by Sebastian Meyer
This short video demonstrates bridging pro‑code and low‑code by using the Model Context Protocol (MCP) to let autonomous AI agents interact with enterprise systems via Logic Apps. It walks through the high‑level setup—agent, MCP server, and Logic Apps workflows—and shows how to connect to platforms like ServiceNow and SAP. The focus is on practical tool choice and architecture so teams can extend existing integration assets to agent‑driven use cases without rebuilding from scratch.
Friday Fact: The Hidden Retry Behavior That Makes Logic Apps Feel Stuck
Post by João Ferreira
This Friday Fact explains why a Logic App can appear “stuck” when calling unstable APIs: hidden retry policies, exponential backoff, and looped actions can accumulate retries and slow runs dramatically. It lists default behaviors many miss, common causes like throttling, and mitigation steps such as setting explicit retry policies, using Configure run after for failure paths, and introducing circuit breakers for flaky backends. The takeaway: the workflow may not be broken—just retrying too aggressively—so design explicit limits and recovery paths.
Your Logic App Is NOT Your Business Process (Here’s Why)
Video by Al Ghoniem, MBA
This short explainer argues that mapping Logic Apps directly to a business process produces brittle workflows. Real systems require retries, enrichment, and exception paths, so the design quickly diverges from a clean process diagram. The video proposes separating technical orchestration from business visibility using Business Process Tracking. That split yields clearer stakeholder views and more maintainable solutions, while keeping deterministic execution inside Logic Apps. It’s a practical reminder to design for operational reality rather than mirroring a whiteboard flow.
BizTalk Server Migration to Azure Integration Services Architecture Guidance
Post by Sandro Pereira
A brief overview of Microsoft’s architecture guidance for migrating BizTalk Server to Azure Integration Services. The post explains the intent of the guidance, links to sections on reasons to migrate, AIS capabilities, BizTalk vs. AIS comparisons, and service selection. It highlights planning topics such as migration approaches, best practices, and a roadmap, helping teams frame decisions for hybrid or cloud‑native architectures as they modernize BizTalk workloads.
Logic Apps & Power Automate Action Name to Code Translator
Post by Sandro Pereira
This post introduces a lightweight utility that converts Logic Apps and Power Automate action names into their code identifiers—useful when writing expressions or searching in Code View. It explains the difference between designer-friendly labels and underlying names (spaces become underscores and certain symbols are disallowed), why this causes friction, and how the tool streamlines the translation. It includes screenshots, usage notes, and the download link to the open-source project, making it a practical time-saver for developers moving between designer and code-based workflows.
Logic Apps Consumption CI/CD from Zero to Hero Whitepaper
Post by Sandro Pereira
This whitepaper provides an end‑to‑end path to automate CI/CD for Logic Apps Consumption using Azure DevOps. It covers solution structure, parameterization, and environment promotion, then shows how to build reliable pipelines for packaging, deploying, and validating Logic Apps. The guidance targets teams standardizing delivery with repeatable patterns and governance. With templates and practical advice, it helps reduce manual steps, improve quality, and accelerate releases for Logic Apps workloads.
Logic App Best practices, Tips and Tricks: #2 Actions Naming Convention
Post by Sandro Pereira
This best‑practices post focuses on action naming in Logic Apps. It explains why consistent, descriptive names improve readability, collaboration, and long‑term maintainability, then outlines rules and constraints on allowed characters. It shows common pitfalls—default names, uneditable trigger/branch labels—and practical tips for renaming while avoiding broken references. The guidance helps teams treat names as living documentation so workflows remain understandable without drilling into each action’s configuration.
How to Expose and Protect Logic App Using Azure API Management (Whitepaper)
Post by Sandro Pereira
This whitepaper explains how to front Logic Apps with Azure API Management for governance and security. It covers publishing Logic Apps as APIs, restricting access, enforcing IP filtering, preventing direct calls to Logic Apps, and documenting operations. It also discusses combining multiple Logic Apps under a single API, naming conventions, and how to remove exposed operations safely. The paper provides step‑by‑step guidance and a download link to help teams standardize exposure and protection patterns.
Logic apps – Check the empty result in SQL connector
Post by Anitha Eswaran
This post shows a practical pattern for handling empty SQL results in Logic Apps. Using the SQL connector’s output, it adds a Parse JSON step to normalize the result and then evaluates length() to short‑circuit execution when no rows are returned. Screenshots illustrate building the schema, wiring the content, and introducing a conditional branch that terminates the run when the array is empty. The approach avoids unnecessary downstream actions and reduces failures, providing a reusable, lightweight guard for query‑driven workflows.
Azure Logic Apps Is Basically Power Automate on Steroids (And You Shouldn’t Be Afraid of It)
Post by Kim Brian
Kim Brian explains why Logic Apps feels familiar to Power Automate builders while removing ceilings that appear at scale. The article contrasts common limits in cloud flows with Standard/Consumption capabilities, highlights the designer vs. code‑view model, and calls out built‑in Azure management features such as versioning, monitoring, and CI/CD. It positions Logic Apps as the “bigger sibling” for enterprise‑grade integrations and data throughput, offering more control without abandoning the visual authoring experience.
Logic Apps CSV Alphabetic Sorting Explained
Post by Sandro Pereira
Sandro Pereira describes why CSV headers and columns can appear in alphabetical order after deploying Logic Apps via ARM templates. He explains how JSON serialization and array ordering influence CSV generation, what triggers the sorting behavior, and practical workarounds to preserve intended column order. The article helps teams avoid subtle defects in data exports by aligning workflow design and deployment practices with how Logic Apps materializes CSV content at runtime.
Azure Logic Apps Translation vs Transformation – Actions, Examples, and Schema Mapping Explained
Post by Maheshkumar Tiwari
Maheshkumar Tiwari clarifies the difference between translation (format change) and transformation (business logic) in Logic Apps, then maps each to concrete Azure capabilities. Using a purchase‑order scenario, he shows how to decode/encode flat files and EDI, convert XML↔JSON, and apply Liquid/XSLT, Select, Compose, and Filter Array for schema mapping and enrichment. A quick reference table ties common tasks to the right action, helping architects separate concerns so format changes don’t break business rules and workflow design remains maintainable.
Microsoft