Welcome to the M365 FM podcast where we explore the people, ideas and technologies shaping the future of work. Why flows break in silence. A flow you built last month has already stopped working and nothing told you. That's the strange part about Power Automate because when a flow breaks, it usually breaks in silence. A report stops going out, a folder stops filling up, and the first person to notice is the one waiting on it. Error handling is how you make a flow. Tell you when something's wrong and how you stop one bad step from taking down the rest. Welcome to the M365 FM podcast where we explore the people, ideas and technologies shaping the future of work. By the end, you'll know how to set it up yourself without writing a single line of code. What error handling really means. Error handling sounds like something a developer worries about, but in Power Automate, it's just a set of choices you make in the designer. Those choices decide what your flow does when a step fails instead of stopping where it stands. That's the whole idea. Picture a flow that watches a Microsoft form and copies each new response into a SharePoint list. You built it in ten minutes. It worked. And then one day, a column comes through empty and the flow stops dead. Nobody gets an email about it, and you only find out when someone asks why their entry never showed up. The idea itself comes straight from coding and it has a name. Developers put their risky steps in a try block, and if something throws an error, a catch block runs instead of the whole program dying. Power automate copies that pattern with visual blocks so you get the protection without typing any code. So error handling is a plan for failure. It won't stop errors from happening and it won't make your flow perfect. What it does is decide the next move after something goes wrong. And that one change separates an automation that disappears from one that speaks up. A few words are worth pinning down before we go further because they come up constantly. A trigger is the event that starts a flow, like a new file landing in a folder. An action is any single step after that, like sending an email or updating a row. A scope is a box that holds a group of actions together, and you'll see why that matters in a minute. One more thing is worth saying. Plainly error handling is not the same as fixing the error. The flow can't repair a rename sheet or fill an empty column on its own, and expecting it to do that is where beginners get frustrated. What it can do is notice the problem, tell the right person, and avoid making things worse while the problem waits. What happens when a step fails? By default, a flow stops the moment an action fails. Each action in the chain runs only if the step before it succeeded. So one broken step ends the run right there. Nothing continues and nothing tells you walk through what actually happens in that moment. A connector reaches out to another service and the request times out or a value arrives empty, or the service pushes back because too many requests arrived at once. Any of those counts as a failure and the run stops. Take the weekly report flow. It pulls new rows from a spreadsheet, builds a summary, and emails it to the team on Monday morning. The step that gets the rows fails because someone renamed the sheet so the email never sends, and the team assumes the numbers were fine because nobody said otherwise. One layer runs before you ever see a failure, and that's the retry power. Automate tries a failed action again on its own, which is why some failures take a while to show up. We'll come back to exactly how many tries it gets because the number changes with your plan. Retries are not a fix for a wrong value though, and this trips people up if a column is empty. Trying again ten minutes later won't fill it. Retries only help with temporary problems, like a brief network blip or a service that's busy for a moment. So when you're dealing with an actual mistake, the retry is just delaying the bad news. The run history is where all of this becomes visible, and it's worth knowing how to read it. Every run keeps a record of each action, and a red mark next to an action tells you exactly where the flow gave up. For a beginner, that single view turns. My flow is broken into this step. Failed at this time. For this reason, failures come in a few flavors and it helps to recognize them. A timeout means the service took too long to answer. A bad value means the data itself was wrong. A throttle means you asked for too much, too fast. A permission problem means the connection lost access. The flow reacts the same way to all four by stopping. But your fix is different in each case, the run after setting. If the default is to stop and stay quiet, the run after setting is how you change it. Every action has a small menu behind its three dots, and that menu lets you say what has to be true about the previous step before this action is allowed to run, you get four outcomes to react to. The previous step is successful. It has failed. It is skipped or it has timed out. Successful is the default. Everyone starts with failed is the one you'll use most because it lets you send a message the instant something breaks. Take a small example. You can picture your flow updates, a row in a Dataverse table, and right after that you add a send an email action. You open run after on the email and tick only the failed box. Now the email fires only when the update breaks and it can say something as plain as the update failed. Please check the flow run. The mental picture is worth holding on to. Instead of one straight line of steps, you're drawing a second path that only opens when something goes wrong. The main path keeps its job and the side path handles the mess. Skipped is the outcome beginners miss most, so it deserves a plain word. A step gets skipped when the flow decided not to run it, usually because a condition above it didn't pass. That isn't an error, but it can still surprise you if you assumed a step. Always runs run after works one action at a time, and that's its main weakness in a flow with thirty actions, wiring a failure path by hand across all of them is slow and easy to get wrong. That's exactly the problem scope blocks were built to solve. Finding the setting is easier than it sounds. Open the flow in the designer. Hover over the action you want to protect. Click the three dots and choose configure run. After a small panel opens with four checkboxes and the successful box is already ticked for you. From there, you decide which extra outcomes should wake the action up. Scopes and the Trycatch idea a scope groups actions together, and the quiet superpower is that run after can be set on the whole block at once. That means you can treat a dozen steps as a single unit. Building. The try and catch pattern in Power Automate takes about three steps. Put your real work inside a scope and name it. Try. Add a second scope below it and name it catch, then set. Run after on the catch scope and tick the failed box so it runs only when try breaks. Now the flow has a safety net. The try scope pulls the rows and builds the report, and if anything inside it fails, the catch scope wakes up and takes over. None of that requires code. The catch scope is where the useful work happens, and two functions carry most of the weight. The result function asks a scope what happened inside it, returning the run history of every action in that block. A filter array action then picks out just the failures, so you're left with the step name and the error message instead of a wall of noise. The workflow function answers a different question. It returns details about the current run, including the run ID, and those details let you build a link straight back to the failed run. Drop that link into your notification and the person reading it can jump to the exact run in one click. Microsoft adds a caution here that's worth repeating, because it's easy to overdo. Every logging action you add makes the flow longer and slower, so a flow that composes and notifies on every tiny event becomes its own problem. Log the failures that matter and leave the rest alone. You can add a third scope if you want one, and it's called. Finally, a final scope holds cleanup steps that should run no matter how the scope ended, like closing a record or clearing a temporary file. It's the same idea as the catch, just aimed at tidying up instead of reporting the problem. The pattern is worth building once and then reusing. Save the try and catch pair as a template and every new flow starts with a safety net already in place. That small habit pays off the first time a flow fails on a Friday afternoon, and you hear about it before your users do. One detail decides whether all of this actually helps you, and it's the peace beginners tend to skip. It only shows up after an error is caught, so keep it in mind while we cover the settings that control retries and timeouts. Terminate retries and timeouts. Catching an error is only half the job because you still have to decide what the flow does next. Sometimes the fairest answer is to stop on purpose, and that's what the terminate action is for. Terminate ends the flow and stamps it with a status you choose, such as failed plus a message. You might imagine a flow that builds a customer. If the payment step fails, you don't want the rest of the flow to carry on and email a receipt for money that never moved. Terminate stops the run cleanly and leaves a status that says exactly what happened. Retries are the other half and you can tune them on each action. A fixed retry policy waits the same amount of time between attempts, while an exponential policy waits longer after each one. Microsoft recommends exponential because it stops you hammering a service that's already struggling and gives it room to recover. The default numbers are worth knowing, and they depend on your plan on a typical Microsoft three. Sixty five plan, the default policy gives you up to two retries at growing intervals on the higher plants that jumps to as many as twelve. If you set your own policy, the ceilings are ninety attempts, a minimum delay of five seconds and a maximum delay of one day. Timeouts are the last piece, and they explain a lot of my flow is stuck moments. When a step makes a request and waits for an answer, it gives up after one hundred and 20s, which is two minutes. Requests built to run in the background can be set to wait far longer up to thirty days. Put the retry numbers together with the timeout, and you can see why a broken flow sometimes sits there for a while before it admits defeat. It isn't frozen, it's retrying, and each attempt has to time out before the next one starts. You set the retry policy in the settings of the action itself, so you can be generous on one step and strict on another. A step that calls a busy service might deserve a patient policy, while a step that writes to a record you care about should fail fast so a human can look at it. One caution with retries because they can hide a real problem. If a step only ever succeeds after a retry, that's a signal. The service behind it is unhealthy and the retry is covering for it. Watch for patterns like that because they usually show up as a slow flow long before they show up as a failed one. Logging errors before your users find them. Everything so far makes a flow. Notice a failure. Logging is what makes a person notice it, and that's the part that changes your week. The simplest setup writes the details into a SharePoint list and then notifies the owner. Each failed run adds a row and the row can hold the flow. Name, the step that failed the error message, and a link back to the run. When something breaks, you have a record. Instead of a mystery, you get a little help for free here. Power automate already emails flow owners for common and critical failures. Like a connection that's broken or a flow that's being throttled. Those emails are a safety net, not a full plan, because they won't tell you that a step quietly returned the wrong data. When you run a lot of flows, application insights is the step up. You can connect it to your cloud flows and let it alert you when something fails, which beats reading run histories one by one. The detail I said beginner skip is the one that decides whether catching an error actually helps you. Beginners often log the fact that a failure happened, then leave out the part that would help. A row that says flow failed tells you nothing. You can act on a row that names the step, quotes the error and links to the run turns a two hour hunt into a five minute fix. One warning before you alert on everything. If every flow emails on every hiccup, people stop reading the emails and then the one that matters gets buried. To pick the failures that actually need a human and stay quiet about the rest. A good notification is short because the goal is a fast decision and not a long report. Teams makes a natural home for it since a channel message is easier to spot than an email that lands in a crowded inbox. Mistakes beginners make. Even with a good plan, beginners run into the same handful of traps. Knowing them in advance saves you a bad afternoon. One mistake is leaving the critical path uncovered. If the step that matters has no run after on it, a real failure is never caught and the flow simply stops the way it did before you learned any of this. Catching the error and then doing nothing with it is another a catch scope that runs an empty action or just ends quietly hides the failure instead of surfacing it, which is worse than no plan at all because you think you're covered. Deep nesting is a third. Microsoft caps how deeply you can nest actions at eight levels, and a flow that stacks scope inside scope. Inside scope gets hard to read and harder to debug. flat and clear beats. Clever every time. Trusting retirees to fix everything is a fourth. They only help temporary problems. So when a wrong value fails again after the delay, the tool gets the blame for a data problem it can't solve. Alerting on everything is a fifth and it trains people to ignore alerts. The sixth is quieter but expensive. Failed actions still count toward your request limits, so a flow that fails in a loop burns through its allowance, and a flow that keeps failing is switched off after fourteen days of continuous failure. That last one is the real cost of silent failure. An unhandled error doesn't just break one run left alone, it can quietly turn your automation off. A seventh trap is more of a mindset, and it's the easiest one to fall into. Beginners often add error handling at the very end after the flow is built and already in use. That's backwards. The cleanest time to add a failure path is while you're building the step, because that's when you still remember what could go wrong. Where this fits in Microsoft three hundred sixty five and Azure. Zoom out for a second because where Power Automate sits explains a lot about what it can and can't do. Power automate lives inside Microsoft three hundred sixty five and the power platform, and it's built on top of a service in Azure called Logic Apps. Same idea underneath. Different crowd on top. Power automate is made for makers and everyday users working inside Microsoft three hundred sixty five, while Logic Apps is made for IT pros and developers working in Azure. Both connect to hundreds of services, so the choice is rarely about connectors on error handling. Specifically, Logic Apps gives you more. It offers deeper retry control, more advanced handling, and enterprise monitoring through Azure's own tools, which is why teams move their most critical backend integrations there. A practical side is worth mentioning for a beginner. Power automate is included with many Microsoft three hundred sixty five licenses, which is a big part of why it's the natural place to start. Logic apps usually runs on a separate Azure subscription with its own billing, so it carries a different kind of commitment. A second difference is about who maintains the thing. A power automate flow can be owned and edited by the person who uses it, which keeps the work close to the team. A logic app usually sits with a development or platform team, which adds process and can slow a small change down. Here's the guidance for where you are right now. Stay in power, automate while you're learning. And while the flow supports your team, when a flow becomes the backbone of a business process and real people are on the hook when it fails, that's the signal to look at logic apps. One fair note on that comparison the line between the two isn't a rule. Microsoft hands down, and the community guide that maps it out is open source, so treat it as a helpful judgment call rather than a hard boundary. The one habit worth building. Here's the short version to take with you. Error handling comes down to a plan for the moment. A step fails and you build it from a few pieces. Run after tells the flow what to do next. A scope gives you a try and catch. Terminate ends a run on purpose. The retry policy decides how patient the flow is and logging makes sure a person hears about it. The goal was never a flow that can't fail. The goal is a flow that fails out loud, so you fix it on your terms instead of finding out from someone who was waiting on it. Before you go, sit with one question. If you looked at your flows right now, which one would fail without ever telling you if this made the topic feel less intimidating? Subscribe to M365 FM to master the tools and the mindset shaping the future of work.