Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

Support Engineering Weekly

Support Engineering Weekly artwork

Apps, Workflows, or AI Agents? Choosing the Right Tool

Oct 25, 202625 minAudio
ShareXLinkedInFacebookWhatsAppEmail

In this episode of Support Engineering Weekly, Alex and Maya examine the architectural differences between human interaction, deterministic execution, and adaptive reasoning. Rather than starting with a technology choice, the discussion starts with the nature of the work and asks which execution model best fits it. The episode begins with Power Apps and the role of applications in providing structured human experiences. It then moves into Power Automate and deterministic workflows, where triggers, rules, actions, expected outcomes, and auditability can be explicitly defined. The discussion then explores AI agents and the situations where reasoning, ambiguity, unstructured information, multiple knowledge sources, and dynamic tool selection make agentic execution useful. Alex and Maya examine why an agent should not simply replace a deterministic workflow and why bounded tools, permissions, escalation paths, and observability matter when agents can take action. The conversation then moves beyond the idea of choosing a single tool. Power Apps, Dataverse, Power Automate, AI agents, enterprise systems, and human decisions can be composed into a governed architecture, with each execution model responsible for the work it is best suited to perform. Finally, the episode examines business data, governance, security, ALM, monitoring, licensing, AI capacity, and human-review costs. The central lesson is simple: applications, workflows, and AI agents are not competing replacements for one another. They are different execution models that can coexist when architecture starts with the work. Chapters 00:00 - Choosing the Right Execution Model 05:09 - Apps for Human Interaction 07:00 - Workflows for Deterministic Execution 10:22 - Agents for Reasoning and Ambiguity 14:50 - Composed and Governed Architecture 19:00 - Data, Governance, and Total Cost 22:44 - The Architecture Rule Learn more: The full technical article, references, and supporting resources are available through the Support Engineering Blog at https://blog.sadhan.ch/.

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

You are listening to Support Engineering Weekly. Imagine this scenario. You're sitting in a Q3 architecture planning meeting. Oh yeah, we have all definitely been there. Right. And the executives are just thrilled about the new budget. The product managers are, you know, riding high on the latest tech trends. Naturally. And everyone is looking at your massive backlog of these clunky outdated business processes. And the prevailing wisdom in the room is just, well, let's just throw an AI agent at all of it.

Which is honestly a terrifying sentence to hear. It really is. Because you're an engineer. And right now your internal alarm bells are just absolutely deafening. Oh, I bet. You're immediately thinking about the exorbitant compute costs. Exactly. You're thinking about the sheer lack of control. And most importantly, you're thinking about what actually happens to the poor user on the other end when an autonomous agent decides to get, let's say, a little too creative with their data. Yeah. Creative data is usually not a good thing.

No, it is not. But what if I told you that you don't actually have to choose between keeping the system perfectly rigid and letting an AI run totally wild? What if you could put that AI inside a deterministic cage? I mean, that is the ultimate modern engineering dilemma, right? We've been handed this incredible, almost magical new capability with generative AI. Right. And suddenly, every single business process looks like a very expensive, very unpredictable nail. Yeah, exactly. But the secret to surviving this shift

isn't resisting the technology. It's understanding exactly how to constrain it. I'm Alex. And I'm Maya. And we really want to thank you for joining us for this deep dive today. We're taking on a very specific mission. We are. We are breaking down a fantastic piece of source material, an article by Sandin Chandra from the Support Engineering Blog. It's such a good read. It really is. And our goal for this deep dive is to answer a critical architectural question. Like, how do you actually choose between power apps, deterministic workflows, and AI agents

based on the true nature of the work you're trying to accomplish? To get to that answer, we really need to change how we frame the problem. Yeah, how so? Well, the central question for engineers is no longer should we use AI. Right, right. That is entirely the wrong starting point, because it just focuses on the tool rather than the task. Which is such a common trap. Totally. The question you need to be asking every time you look at a backlog item is, which execution model best matches the actual work happening here? Let's pause right there, actually, and establish the baseline.

Because the source lays out three primary execution models. And having this mental framework is honestly a game changer for system design. It really clarifies things. It does. So first, you have interaction, which maps to your power apps. Second, you have deterministic execution, which maps to power automate. And third, you have reasoning, which maps to your AI agents. And mapping the work to those specific models is exactly how you avoid an operational disaster. Yeah, because if you start with a tech first. Right, if leadership comes to you and says, well,

we just pay it for co-pilot capacity, where can we force it in? Oh, the classic top-down mandate. Exactly. You are virtually guaranteed to build the wrong thing. You have to start by analyzing the work itself. Like, does a human being need to interact with this process directly to feel comfortable? Are the business rules mathematically known in advance? Or does the work contain inherent ambiguity that requires interpretation? I feel the need to push back heavily on the industry hype right now, because I see this mistake constantly. Teams want to use a massive, large language model agent

to do something like route a standard IT ticket based on a simple drop-down menu selection. Oh, I've seen that too. It's wild. It makes no sense. To me, from an engineering perspective, using an AI agent for a straightforward rules-based task is like using a multi-million dollar supercomputer to flip a light switch. That is the perfect analogy. Right. Like, why overcomplicate the system? A simple mechanical switch, or in this case, a basic if-then workflow? Does the job flawlessly, instantaneously, and at a fraction of the compute cost?

And there is a massive, tangible cost to getting that mapping wrong. If you correctly identify the type of work before you touch a single piece of technology, you will save your team from crushing technical debt six months down the line. So true. Because when you force deterministic work into an agentic model, you lose predictability, and you just bleed money on token consumption. Yeah, you're just paying for an AI to guess at a fixed rule. Exactly. But conversely, when you force reasoning work

into a deterministic model, you end up with incredibly brittle workflows. Those nightmare logic trees with thousands of conditional branches. I hate those. The ones that shatter the moment the real world changes even slightly. Right. So to you, the listener, accurately identifying the type of work is your first and really your most important line of defense. But before we get to the shiny new AI agents and how they reason, we have to establish the foundational layers. The basics. Right. What happens when human interaction

and strict unbending rules of the priority? Well, that brings us to our first two execution models, which are apps and workflows. Let's look at power apps first. OK. This is the natural architectural choice when the human experience is paramount. When a person needs to interact with highly structured forms or when they require a carefully guided interaction to prevent data entry errors. Or when they just need to clean dashboard summarizing the current state of the business, right? Exactly. We are dealing with two distinct flavors. Here we have Canvas apps and model-driven apps.

I think it's worth clarifying how they split that interaction workload. It definitely is. So Canvas apps give you that pixel-perfect, highly customized user experience. You use them when the interface needs to look a very specific way. Like matching corporate branding or a specific mobile layout. Right. Model-driven apps, on the other hand, are your data-heavy, process-driven interfaces. They sit directly on top of Microsoft Dataverse. And their UI is generated by the underlying data structure itself. Got it. But regardless of which one you choose,

the key takeaway is critical. An AI agent does not automatically make a better user interface. I could not emphasize that enough. There is this pervasive and slightly dangerous assumption right now that chatting with a bot is always superior to clicking a button. It's such a weird trend. It is. Think about your own daily workflow. If I just need to approve an expense report for a $50 software license, I do not want to have a conversational back and forth with an AI to get it done. Hello. I would like to approve this. Yes, please approve it. Right.

I just want to open a structured form, instantly verify the total amount, and click a giant button that says approve. Because natural language is inherently inefficient for a highly structured repetitive task. Exactly. And once that approved button is clicked, we transition seamlessly into the second execution model, which is deterministic execution. This is the domain of power automated. Yes. You deploy this model when the process is entirely predictable. The trigger event is known. The business rules are explicit and documented. The sequence of execution is repeatable.

Exactly. And the expected outcome is clearly defined. Let's break down the mechanics of that sequence, because the predictability isn't just a perk. It is the entire value proposition. It really is. The source material maps it out so logically. You move from trigger to rules to actions to validation and finally to outcome. It's a straight line. Or at worst, a highly mapped predictable branching tree. Right. And the true value of that sequence lies entirely in its rigidity. Let's look at a standard employee onboarding process.

OK. When a new record is created in the HR database, that is your unambiguous trigger. Clear as day. The rules dictate that this specific role needs an email account, a laptop requisition, and read only access to specific SharePoint sites. Right. The automated actions go out and execute those exact steps via APIs. The validation phase checks the server responses to ensure the accounts were actually created without error. And the final outcome is a fully onboarded employee. Exactly. We know exactly what happens at every millisecond

during every single step. Which brings up a critical engineering question that I think really often gets lost in all the AI excitement. What's that? Well, if an auditable fixed path is legally required for compliance, say in financial reporting or when handling sensitive health care data, why would you ever invite an AI to improvise the sequence? You absolutely wouldn't. If the auditor comes knocking and asks, how exactly did this sensitive patient data move from system A to system B on Tuesday at 4 PM? You need a real answer.

Right. A deterministic workflow gives you a definitive, mathematically provable log. It says the API was called here. The payload was this, and it was written here. Yeah. Whereas an autonomous agent operating on its own might give you a slightly different path, depending on the prompt it generated internally that day. Which is unacceptable. You can't just hand an auditor a prompt history and call it compliance. Exactly. If the path is already known and optimized, adding autonomy just injects complexity and operational risk

without delivering any tangible business value. So here is a challenge for you, the listener. Sometime this week, I want you to audit your current project backlog. That's a great idea. Look closely at all those proposed AI initiatives that the business site is pushing for. How many of them are actually just deterministic workflows wearing a disguise? Probably a lot of them. Right. How many of those requests just need a rock solid power automated flow? But someone slapped the word agent on the requirements document just to secure the funding.

It is a highly necessary audit to perform. Because at the end of the day, our job as engineers is to deliver reliable, secure business outcomes, not to act as integration testers for every trending technology. But let's be honest about the reality of enterprise systems. The real world rarely fits neatly into a perfectly predictable linear sequence. Sadly true. What happens when the system encounters messy, unstructured, completely unpredictable inputs? A rigid workflow just crashes or throws a generic error. And that is precisely the breaking point

where we transition from deterministic rules to embracing ambiguity with AI agents. This is the third execution model, reasoning. So mechanically speaking, where do agents step in and add actual measurable value over a workflow? Agents become incredibly powerful and frankly necessary. When you are dealing with ambiguous input, multiple possible resolution paths, highly context dependent decisions, and massive amounts of unstructured information. Give me an example.

Let's use a real world nightmare scenario. A VIP customer emails your support desk. The email says, the system is broken again. But they've pasted a massive uncropped screenshot on the body, forwarded a messy thread from three weeks ago and vaguely demanded a refund. Oh, I've gotten that exact email. Right. A deterministic workflow fails at step one. It doesn't know how to extract the account ID. It doesn't know what the screenshot means. It has absolutely no structure to parse. But how do agents handle that differently? An agent powered system uses a large language model

to act as a reasoning engine rather than just a fixed script. So instead of just looking for a specific order number field, it can read the text, recognize the user's frustration, and look for identifying details like an email address. Right. And then it uses that unstructured input to determine the next best step. Exactly. The agent would decide to trigger three specific tool calls, look up the customer's account based on the email address, search the knowledge base for that specific error in the screenshot, and query the order history to find the most recent transaction.

So instead of just blindly following a script, it is it's actually orchestrating tools based on this specific context of that request. Yeah. And that's the superpower. That ability to handle messy reality without requiring the human to pre-organize everything into a rigid machine readable format first, that that is what makes them different. It requires actual reasoning to untangle that mass. And the source article breaks down how an agent handles this through the agent reasoning loop. Yes. It completely abandons the straight line. Instead, it relies on a continuous cycle.

Goal, context, reason, action, tool, evaluate. Let's really look under the hood of how that loop operates, because it's fundamentally different from traditional programming. In a workflow, the execution sequence is hard-coded. But with an agent, the agent is dynamically determining the sequence based on the evolving context. The walk us through hell with processes that VIP customer email. Sure. So the agent starts with its overarching goal. Let's say resolve the customer support issue. OK. First, it gathers context by reading the messy email thread

and analyzing the screenshot using vision models. Then it moves to reason. It internally deduces, I need to find this customer's account to check their recent invoices. Makes sense. That reasoning dictates the action, which is search the database. To do that, it selects a specific tool, perhaps a dataverse search connector. And this next step is where the real magic happens, right? The evaluate phase. Yes. Let's say the tool returns an error, or it returns three different customers with the same name. Oh, classic data issue. Right.

A deterministic workflow would just throw a failure code and stop. But the agent evaluates that result, realizes its action didn't fulfill the goal, and feeds that failure back into the reasoning loop. So it tries again. Exactly. It might reason, OK, names search failed. Let me extract the email domain from the forwarded thread and try searching by domain instead. It dynamically alters its own execution path until it solves the problem. OK, as a support engineer who has spent years debugging systems, I have to admit, the kind of autonomy terrifies me.

I completely understand why. An agent dynamically choosing its own path, looping through failures, trying different tools, sounds like an absolute operational nightmare to maintain. It really can be. If I get an escalation to 2 AM because a process failed, and I have to read the system logs to figure out what happened, I do not want to decipher in AI's internal monologue and reasoning process. No one wants to read that at 2 AM. I want to see a clean, failed API call on step four of a structured workflow. How on earth do we implement this reasoning capability

without letting the system go completely off the rails? Your fear is completely justified. Capability without strict boundaries creates massive operational risk. If an agent is allowed to query any database and send any email, it will eventually make a catastrophic mistake. Yeah, inevitably. And that exact fear brings us to the most important architectural pattern in this entire deep dive, composition. The composed architecture and governed workflows. This feels like the missing link between the hype of AI and the reality of enterprise engineering.

It is. The source introduces a concept of an interactive execution model selector. If we translate the logic of that selector into an engineering strategy, it essentially says this. If human interaction is the dominant requirement, build a power app. If the process is predictable and highly auditable, build a power automate flow. If the inputs require complex reasoning and are unpredictable, use an AI agent. But what if your business process requires all of those things at once? You don't pick just one.

You build a composed architecture. You integrate them so they cover each other's blind spots. And the key to making this safe, the solution to your 2 AM support nightmare, is a specific pattern called the governed agent workflow. Yes. Do rule is simple. You never, ever treat an AI agent as an unrestricted top level process engine. Instead, you cage the AI. Exactly. You put the reasoning engine entirely inside a deterministic workflow boundary. Let's map this out. Using the employee support scenario from the article,

because it beautifully illustrates how these pieces lock together. It's a great example. Imagine an employee needs help with a highly complex, unusual HR issue. First, they interface through a power app. That provides the clean, structured user experience, no guessing what to type, just clear options. Right. And that power app is heavily relying on Dataverse to securely hold the business state and the user's identity. Then Dataverse feeds that state into a deterministic orchestration controlled entirely by Power Automate.

Yep. Power Automate is the master controller running the show. It handles all the standard routing, the logging, and the API calls. But here is where the handoff happens. Power Automate hits a step where the employee's request is too ambiguous. It can't map it to a known rule. So what does it do? So Power Automate effectively pauses its execution and invokes the AI agent as a specialized sub-process. The agent goes off into its reasoning loop, reads the ambiguous request, gathers knowledge from approved HR documents, and formulates a proposed solution.

Crucially, the agent does not execute that solution. No, it does not. It doesn't update the database or send the final email. It passes its decision back to the deterministic workflow. Exactly. And because this might involve sensitive HR data, the workflow enforces a human in the loop step. A manager has to look at the AI's proposal and give explicit approval. And once the human clicks approve, Power Automate takes over again, updates Dataverse securely, and the new state is reflected back in the Power app. Think of it like an industrial assembly line.

The deterministic workflow is the conveyor belt. I love this analogy. It moves the product from station to station with absolute perfect reliability. You can measure its speed, you know exactly where the product is at all times. Right. The AI agent isn't running the factory. The agent is simply the highly specialized inspector sitting at station four. When a custom oddly shaped part comes down the line that the standard machines can't handle, the belt stops. Yep. The agent examines the part, figures out how it needs to be processed, performs its specific reasoning

task, and then puts it right back on the rigid conveyor belt. And that human approval step? That's the emergency break on the factory floor. That is a brilliant way to visualize it. The conveyor belt keeps everything moving safely, and the specialist handles the weird edge cases. And we really need to remind you, the listener, that keeping human beings stationed at those emergency breaks is absolutely essential. No, without a doubt. Whenever there is a significant financial impact, an irreversible action like deleting a record or a strict compliance responsibility at stake,

a human must validate the agent's reasoning. Right. You only increase the autonomy of the agent, letting it bypass the human as your systemic observability, your testing confidence, and your governance controls mature. Which naturally transitions us into discussing the foundation that makes all of this possible. Let's look at dataverse governance and total costs. Let's do it. Starting with dataverse. There is a dangerous misconception floating around that if you buy a smart enough large language model, you don't need highly structured relational data anymore.

Oh, I hear that all the time. Right. The assumption is the AI will just read your chaotic files and figure it out. The source material strongly refutes that idea. And honestly, so does basic engineering logic. AI does not reduce your need for pristine business data. It drastically amplifies its value. Completely. An LLM on its own just predicts the next word. It needs dataverse to provide governed relational business context. Yes. Agents require clean metadata. They need to understand the structural relationships

between an invoice and a customer record. And they need that context to make accurate decisions during their reasoning loop. Let's face the harsh reality here. If your underlying base data is a disorganized mess of duplicate records and outdated fields, an AI agent isn't going to fix your business. Nope. It is just going to help you make terrible factually incorrect business decisions at an incredible scale in speed. It operates as a massive garbage in garbage out multiplier. Which brings us to the most crucial guardrail.

Governance. A lot of organizations treat AI like it's an entirely new paradigm that needs new rules. It really isn't. Right. The source is clear. Agents do not get to exist in a separate governance universe. The existing security controls established across the power platform must still apply. Exactly. AI just introduces a new type of actor that has to operate inside those established walls. Specifically, we need to talk about how things like data loss prevention or DLP policies apply to an agent.

This is huge. With a traditional app, DLP stops the user from exporting sensitive data. With an agent, DLP means strictly limiting which databases and APIs the agent is allowed to access during its reasoning loop. Yes. If it is an IT support agent, you use DLP to ensure it physically cannot query the HR salary database, even if it hallucinates and decides it wants to. You enforce least privilege access at the tool level. Exactly. You manage the agent's prompts and behaviors

through standard application lifecycle management, pushing updates from dev to test to prod, just like any other piece of code. If we pull back and connect all of this to the broader picture of enterprise architecture, we have to talk about the economic reality. We have to talk about cost. Because evaluating these execution models is not a simple equation of, well, workflows are cheap and agents are expensive. No, it's far more nuanced than that. You have to evaluate the total cost of ownership required to achieve a reliable business outcome.

Right. If you are using a deterministic workflow, you are paying a tiny fraction of a cent for predictable API calls. It's incredibly cheap compute. But if you use an agent, you are burning token capacity for every single step of that React loop. Exactly. If an agent takes a 10-step reasoning loop, evaluating tools, failing, retrying, parsing context, just to do a data lookup that a predefined workflow could have executed in two fixed steps, you aren't being innovative. You are just burning expensive generative compute

and company money for absolutely no reason. You have to factor in the AI token capacity, the power platform licensing, the cost of premium API connectors, the overhead of monitoring a non-deterministic system, and the literal hourly cost of the humans required to review the agent's output. So synthesizing this massive mindset shift into a cohesive enterprise strategy, the emerging pattern for successful organizations is coexistence. It really is. It is not about ripping out traditional automation and replacing it with agents wholesale.

It's about combining them logically based on the work. Which brings us to the core philosophy of this entire deep dive. If you take away absolutely nothing else from our conversation today, remember this architectural mapping. This is the golden rule. Use apps when you need structured human interaction. Use data to provide pristine context. Use workflows to maintain rigid control and orchestration. Use agents only when you require dynamic reasoning.

And wrap robust governance around all of them. That is how you build a resilient, scalable, modern enterprise system. You don't force a workload into one execution model just because it's the newest tool on the market. You compose them thoughtfully to solve the actual business problem in front of you. And I want to leave you with a final forward-looking thought to chew on as you go back to your own architecture meetings. As you start building these composed architectures, putting the AI safely inside the workflow,

what happens when the line between those models begins to blur? That's a fascinating question. If your AI agent is operating inside a deterministic workflow boundary, but over time, that agent starts recognizing repetitive patterns in its own reasoning loops. And it starts proactively suggesting entirely new deterministic workflows for you to build to save compute cost. Where does your traditional engineering boundary and in the agents architecture begin? You've been listening to Support Engineering Weekly

from the Support Engineering Blog. For the full articles, references, and technical resources from today's discussion, visit the link mentioned in the description. Until next week, keep troubleshooting, keep learning, and keep engineering. Thank you for listening to Support Engineering Weekly. This podcast is available on Apple podcast, Spotify, iHeartRadio, and other major podcast platforms. Follow the show on your preferred platform and never miss an episode.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Microsoft Weekly — November 16-20, 2026

    Nov 20, 202656 minAudio

    What happens when a routine network maintenance operation triggers a failure deep inside a cloud provider's authentication infrastructure? In this week's episode, Alex and Maya investigate how a seemingly isolated...

    Credit the people on this episode

  2. When Redundancy Fails: Inside Microsoft’s Network Stampede

    Nov 17, 202633 minAudio

    How can a routine network capacity upgrade trigger a global cloud outage - and why can the very systems designed to protect availability make the failure worse? In this Support Engineering Weekly bonus episode, Alex and...

    Credit the people on this episode

  3. From Microsoft Announcement to Completed Change

    Nov 15, 202623 minAudio

    Microsoft 365 administrators deal with information from several places: the Microsoft 365 Roadmap, Message Center, and Service Health. But knowing where to find an update is only part of the challenge. The real question...

    Credit the people on this episode

  4. Microsoft Weekly — November 09–13, 2026

    Nov 13, 202623 minAudio

    A server under pressure fails its health checks. Automated traffic management removes it from service, pushing even more load onto the remaining infrastructure. What was designed to protect the system becomes part of...

    Credit the people on this episode

  5. Planner Premium Isn't Project Online — So What Is the Gap?

    Nov 8, 202621 minAudio

    Microsoft Project Online is approaching retirement - or, in this case, its retirement date has already passed. But replacing a project management platform is not as simple as moving tasks from one product to another. In...

    Credit the people on this episode