Why these patterns matter more than the flow itself
Power Automate patterns are what keep a useful workflow from turning into a fragile mess six months later. Anybody can drag together a flow that sends an approval, updates a list, and posts to Teams. The harder part is building it so your process still holds up when someone’s out of office, a request shows up half-filled, or the handoff lands with the wrong team.
That’s usually where approvals, handoffs, and exceptions start to crack. Not because Power Automate can’t do the job, but because most business processes come with edge cases nobody bothered to map at the start. And those edge cases? That’s often where the real work is.
If you’ve seen this play out in a real environment, you probably know the drill: the “happy path” looks great in a demo, then Operations starts asking the questions that actually matter. What happens if the approver doesn’t respond on time? What if Finance rejects it, but Procurement still needs a heads-up? What if the request gets halfway through and turns out to belong to another department?
Those questions define the process. The flow is just how it gets delivered.
Before you build any of this, it helps to think about process design before automation. That one step can save you from rebuilding the same flow three times because the business logic was never really nailed down.
The three workflow situations you should design for first
Most internal automations I run into fall into three buckets:
- Approvals: someone has to review and decide.
- Handoffs: work moves from one person or team to another.
- Exceptions: something doesn’t fit the normal path and needs different treatment.
They show up everywhere: purchase requests, HR onboarding, contract review, change management, intake forms for IT or operations. Even a “simple” document review flow usually has all three tucked inside it somewhere.
The common mistake is treating these like separate automations. In real life, they overlap. An approval kicks off a handoff. A handoff exposes an exception. And exceptions usually send you right back to a human decision.
Instead of building one giant flow with branches all over the place, it’s usually smarter to think in reusable patterns. That gives you something you can repeat across departments without rebuilding the whole thing every time.
Pattern 1: Approval with a clean decision state
The first pattern is the one almost everybody needs: a request comes in, someone reviews it, and the process moves based on that decision. Simple enough on paper. Where teams get burned is how loosely they store the result.
If your approval outcome only lives in an email or a Teams notification, that can come back to bite you later. You want a clear decision state in a system your flow can read from and report on. That might be a SharePoint list, a Dataverse table, or even a SQL table if the process is further along.
What this pattern should include
A solid approval pattern usually tracks:
- Request ID
- Requester
- Approval owner
- Status such as Pending, Approved, Rejected, Returned, or Cancelled
- Decision date
- Comments or reason
- Next action owner
That structure matters because “approved” is not always the end of the story. Sometimes it means approved for budget, not implementation. Sometimes “rejected” really means send it back for revision, not kill it completely. If all of that gets flattened into a yes-or-no branch, the flow gets rigid fast.
The better move is to treat the approval as a state transition. Sounds more technical than it is. All it really means is this: every decision should move the item into a clearly named status the next step can understand.
If you want a broader look at approvals and workflow routing, that’s a good companion to this pattern.
One perspective teams often miss
Approvals are also an audit trail, not just a task. That matters more than a lot of teams expect. Once finance, legal, HR, or operations gets involved, somebody is eventually going to ask who approved what, when they approved it, and what information they had in front of them at the time.
So even if the process feels lightweight right now, build it like that history will matter later. Because, honestly, it usually does.
Pattern 2: Sequential handoff with explicit ownership
A handoff pattern is what you use when the work itself needs to move—not just the decision. Think of a new vendor request that starts with a department manager, then goes to procurement, then finance, then IT for system setup. No single approval covers all of that.
The key is explicit ownership. At each stage, your process should answer one basic question: who owns the next action right now?
If that answer only lives in somebody’s head, the workflow is brittle. If it lives in a field your system updates automatically, the handoff becomes trackable and a whole lot easier to support.
What a good handoff flow looks like
In practice, a clean handoff pattern usually does four things:
- Updates the status to reflect the current stage
- Assigns the next owner or queue
- Sends a targeted notification with the right context
- Logs when the handoff happened
Simple list, big payoff. People stop asking, “Whose turn is this?” Managers can see where requests are piling up. Support teams can troubleshoot without bouncing between five different tools.
One thing I’d strongly recommend: route to roles or queues when possible, not hard-coded individuals. If your flow always sends work to one named person, you’ve basically turned org-chart maintenance into part of the automation. Nobody wants that job.
Use a team mailbox, a Microsoft 365 group, a SharePoint-maintained routing table, or a Dataverse lookup if the process is important enough. That way, when someone changes jobs or disappears for a week on vacation, you don’t have to edit core logic just to keep work moving.
Pattern 3: Conditional routing based on business rules
Once a process gets past the basics, routing logic almost always shows up. Requests over a certain amount might need senior approval. Contracts involving customer data may need legal review. Hardware requests may go to one fulfillment team while software requests go somewhere else.
This is one of the places where Power Automate can be incredibly helpful—if the rules stay readable. The worst version of this pattern is a flow packed with scattered conditions that only make sense to the person who built it at 11:30 p.m.
The better version keeps routing rules centralized as much as possible. That might mean:
- Using a SharePoint list as a routing table
- Storing thresholds and owner mappings in Dataverse
- Using switch cases with business-friendly names
- Separating routing logic into a child flow can help centralize it, though child flows aren’t always the best approach and can add complexity and governance considerations in Power Automate.
That matters because routing rules change constantly. New departments pop up. Approval limits move. Teams merge. If every rule is buried deep inside one flow, even a small update starts to feel risky.
This is one of the best places to think about long-term maintainability—not just whether the flow works today. If your automation is supposed to remove repetitive workflow steps, it shouldn’t create repetitive admin work for whoever has to maintain it.
Pattern 4: Exception path instead of silent failure
Exceptions are where mature workflows separate themselves from basic ones. And I don’t just mean technical failures like a connector timing out. I mean business exceptions: missing information, conflicting data, duplicate requests, policy violations, or requests that don’t fit the normal route.
A lot of flows treat those like errors. But many exceptions are perfectly valid business outcomes. They just need a different path.
Common exception cases worth designing up front
- The request is incomplete and needs clarification
- The requester picked the wrong category
- The approver didn’t respond within the expected timeframe
- The item already exists, creating a duplicate
- The request violates a rule and needs escalation
- The assigned team can’t process it and needs to reroute it
If you design those as named statuses instead of vague failures, your reporting gets better immediately. “Needs More Info” tells you something useful. “Flow failed” tells you almost nothing.
And this is the part teams often miss: exceptions are usually one of the best signals for process improvement. If the same exception keeps showing up, that’s not just a workflow problem. It may mean the intake form is unclear, the business rules are stale, or the training never covered the real-world scenario.
In other words, exceptions aren’t just obstacles—they’re feedback.
Pattern 5: Time-based escalation without making people hate the system
Escalation is one of those features everybody asks for—and for good reason. Work gets stuck. Approvers go on vacation. Requests sit untouched because the original notification got buried in Outlook or Teams.
There’s a trade-off, though. Bad escalation design creates noise, and noisy systems get ignored fast.
A good escalation pattern usually includes a defined wait period, one reminder, and then a clear next step. That next step might be escalating to a manager, reassigning to a backup approver, or moving the item into an exception queue for review.
What you don’t want is a flow that sends daily nags forever. That doesn’t fix the bottleneck. It just trains people to tune the messages out.
And be careful with auto-approval after a timeout. Sometimes it makes sense for low-risk requests. Sometimes it’s basically a compliance problem waiting to happen. The right choice depends on the process, not the feature list.
How to keep these patterns maintainable
The more workflows you build, the more consistency matters. Not because consistency looks nice, but because it makes support easier. If every flow uses different status names, different ownership fields, and different exception handling, your team winds up relearning the same process in five slightly different versions.
That’s why I like using a small set of standard conventions across Power Automate solutions:
- Consistent status values
- Standard fields for owner, due date, and last action
- Named exception categories
- Shared child flows for notifications or routing
- Documented rules stored outside the flow when possible
If you’re still deciding whether this approach belongs in your stack, it helps to understand Power Platform for automation in the broader sense—not just Power Automate by itself. Some workflows are perfectly fine with a simple SharePoint-backed flow. Others get easier to manage when you add Dataverse, Power Apps, or Teams-based experiences around them.
And not every workflow belongs in Power Automate forever. Sometimes custom development is the better long-term fit, especially when the process has substantial transaction logic, specialized integrations, or demanding performance requirements. If you’re weighing that decision, here’s a practical look at when Power Platform fits.
A practical way to model your next workflow
If you’re building a process for approvals, handoffs, and exceptions, don’t start in the Power Automate designer. Start with a plain-language map.
List the trigger. Then write down the normal path, the handoff points, and the exceptions. For each step, define the owner, the status, and what should happen if the work stalls or the data isn’t usable.
That exercise may sound basic, but it forces clarity early. And clarity is what makes the automation easier to ship, easier to explain, and much easier to maintain once real users start leaning on it.
Your next step is simple: pick one workflow you already know is causing follow-up emails, status confusion, or manual rerouting. Map its approval states, handoff owners, and exception paths on one page before you build anything. You’ll spot the gaps faster, and the flow you create after that will be a lot more useful.

