Contracts expire, licenses lapse, and agreements drift past their renewal dates when tracking relies on human memory. This lesson shows you how to build a scheduled Power Automate flow that queries SharePoint expiry dates daily, sends contextual owner notifications, and routes each renewal through a documented two-step approval chain — automatically resetting the cycle when approved.

Somewhere in your organization right now, a vendor contract is quietly expiring. A software license that costs six figures renewed automatically three days ago without anyone signing off. A data-sharing agreement lapsed last month, and your legal team doesn't know yet. These aren't hypothetical scenarios — they're the everyday reality of organizations that rely on calendar reminders, manual spreadsheet reviews, or the heroic memory of one overworked admin to keep compliance-sensitive documents current.
The core problem isn't that people forget. It's that the system doesn't remember for them. When expiry dates live in a SharePoint list column, they're just data — inert, unactionable, invisible until someone goes looking. Power Automate changes that equation fundamentally: you can build a flow that wakes up every morning, compares today's date against every expiry column in your list, fires targeted notifications to the right owners, then routes each renewal through a structured multi-step sign-off that produces a documented audit trail. When the final approver clicks "Approve," the item's status and next expiry date update automatically, and the cycle resets.
By the end of this lesson, you'll have built exactly that system — and you'll understand the architectural decisions well enough to adapt it to vendor contracts, software licenses, insurance certificates, training certifications, regulatory permits, or any other time-bound obligation your organization tracks.
What you'll learn:
You should be comfortable navigating the Power Automate designer and understand how automated and scheduled flows differ from instant flows — if you need a refresher, Power Automate Flow Types Explained: Automated, Instant, and Scheduled Flows covers that ground well. You should also have worked through at least a basic approval flow before; Building Approval Workflows with Power Automate is a solid foundation. Familiarity with SharePoint list operations in Power Automate and basic expression syntax (the formatDateTime, addDays, utcNow family of functions) will make this lesson move faster.
You'll need:
Before you touch Power Automate, the data model has to be right. A poorly designed list leads to awkward expressions, unreliable filtering, and flows that fail in edge cases. Let's build this deliberately.
Create a SharePoint list called Organizational Agreements (or adapt the name to your context — vendor contracts, software licenses, whatever fits). The critical columns are:
Title (single line of text, built-in) — The human-readable name of the agreement.
AgreementType (choice) — Options like "Vendor Contract," "Software License," "Data Sharing Agreement," "Insurance Certificate." This drives conditional routing later.
ExpiryDate (date only, no time component) — The date on which the current version expires. This is the column your flow interrogates every day.
RenewalLeadDays (number) — How many days before expiry the renewal process should start. Some agreements need 90 days; others need 14. Storing this per-item gives you flexibility without hardcoding it into the flow.
OwnerEmail (single line of text, or a Person column) — The person responsible for this agreement. If you use a Person column, Power Automate can reference the email directly via triggerOutputs()?['body/Owner/Email'].
SecondaryApproverEmail (single line of text) — The manager or compliance officer who provides the second level of sign-off. You can make this a Person column too.
RenewalStatus (choice) — Options: "Active," "Renewal In Progress," "Expired," "Renewed." This prevents the flow from firing duplicate approval requests on the same item.
LastRenewalDate (date only) — Updated automatically when an approval completes. Useful for audit reporting.
RenewalNotes (multi-line text) — Approvers can add context; also used to log rejection reasons.
Tip
Use a "Date Only" column type (not "Date & Time") for ExpiryDate. When Power Automate reads a Date Only column from SharePoint, it returns a string like "2025-09-30T00:00:00Z". This predictable format makes your date comparison expressions simpler and avoids time zone math headaches that plague Date & Time columns.
Populate three or four test rows with realistic data. Set one ExpiryDate to today plus 30 days, one to today plus 7 days, one to today plus 1 day, and one that's already past. Set RenewalLeadDays to 30 on most of them. Set RenewalStatus to "Active" on all of them. You'll use these for testing each logic branch.
You have two architectural options for triggering expiry checks, and the choice matters more than it appears.
Option A: Recurrence trigger (scheduled flow) — The flow runs on a fixed schedule (daily at 7 AM, for example), queries the SharePoint list, loops through every item, and processes each one. This is the right choice for most expiry scenarios because expiry is a time-relative concept, not an event that SharePoint natively fires.
Option B: "When an item is modified" automated trigger — Fires every time someone changes a list item. You could pair this with a condition that checks if the ExpiryDate column changed, then recalculate notification timing. This works for real-time reaction to date changes but won't catch items that were set up months ago and have silently approached their expiry.
For recurring approval workflows with expiry dates, Option A is almost always correct. You want proactive, systematic sweeps — not reactive triggers that depend on someone touching the record. Scheduling and Managing Time-Based Flows in Power Automate: Recurrence Triggers, Time Zones, and Business Hours Logic goes deep on the nuances of recurrence configuration, including time zone alignment, which matters when your SharePoint site and your users are in different regions.
Warning
If you run a daily scheduled flow that processes 500+ items and each item potentially triggers an approval, you will hit action throttling limits. Power Automate's default is 100,000 actions per 24 hours for a standard environment, and each approval action is surprisingly expensive in terms of internal action count. For large item counts, consider splitting your flow into a "scan and flag" flow that updates a column, and a separate "process flagged items" flow that handles approvals. This lesson covers the full pattern for moderate list sizes (under 500 items needing daily processing).
Create a new Scheduled Cloud Flow. Set the recurrence to every 1 day. Set the start time to something like 7:00 AM in your organization's primary time zone. Name it something unambiguous — Org Agreements - Daily Expiry Renewal Flow — following whatever naming convention your team uses. For guidance on naming discipline, Power Automate Best Practices: Master Flow Naming, Testing, and Monitoring is worth reading before you go further.
The first action after your recurrence trigger is a "Get items" action pointing at your Organizational Agreements list. The critical piece is the OData filter query, which does the date math server-side rather than loading every item into the flow and filtering in a loop.
The filter logic you need: return items where ExpiryDate is within the next N days and RenewalStatus equals "Active."
The challenge is that "within the next N days" varies per item (because of the RenewalLeadDays column). You can't express this cleanly in a single OData filter. The practical solution is a two-stage approach:
Stage 1 (OData filter): Pull items where ExpiryDate is less than or equal to today plus your maximum lead time (say, 90 days) and greater than or equal to today, and RenewalStatus is "Active."
Stage 2 (loop with condition): For each item, evaluate whether today is within that item's specific lead window using its own RenewalLeadDays value.
Your "Get items" OData filter query should look like this:
ExpiryDate le '@{addDays(utcNow(), 90, 'yyyy-MM-dd')}'
and ExpiryDate ge '@{utcNow('yyyy-MM-dd')}'
and RenewalStatus eq 'Active'
Note
OData filter expressions in SharePoint require date values in ISO 8601 format with no time component when querying Date Only columns. The utcNow('yyyy-MM-dd') expression formats the current UTC time as 2025-09-15, which matches what SharePoint stores. If you use the full ISO format with the time (2025-09-15T07:00:00Z), the comparison against a Date Only column can produce unexpected results depending on how SharePoint's REST endpoint handles type coercion.
Set "Top Count" to 100 (or higher if your list warrants it) and avoid leaving it at the default unlimited, which can cause performance problems on large lists.
Also add a second "Get items" action below this one — a separate query for items where ExpiryDate lt '@{utcNow('yyyy-MM-dd')}' and RenewalStatus eq 'Active'. These are already-expired items that slipped through the cracks. You'll handle them differently: immediate notification with an "Expired" status update, no approval routing. We'll return to this branch later.
Add an "Apply to each" action, feeding it the value array from your first "Get items" action. Inside this loop, every action runs once per list item that matched your query.
The first action inside the loop is a Compose action to calculate the item's specific alert threshold:
addDays(utcNow(), items('Apply_to_each')?['RenewalLeadDays'], 'yyyy-MM-dd')
This produces a formatted date string representing "today plus this item's lead days." Call this Compose action AlertThreshold.
Now add a Condition action. The question you're asking: is today's date within this item's specific renewal window? In other words, is the ExpiryDate on or before the AlertThreshold?
Configure the condition:
items('Apply_to_each')?['ExpiryDate'] — the item's expiry dateoutputs('AlertThreshold') — the threshold you just computedKey insight
This two-level filtering approach (broad OData filter at the list level, then precise per-item condition in the loop) is a deliberate architectural choice. Doing all the date math in OData would require knowing each item's lead days upfront, which you can't express in a parameterized OData query against a column value. The tradeoff is that you bring more items into the flow than you strictly process, but it keeps the logic transparent and debuggable. For deeper techniques on working with conditions, loops, and variables in Power Automate, including how to avoid common loop pitfalls, that article covers the internals in detail.
Inside the Yes branch of this condition, place all the logic for items that need renewal action. The No branch can be left empty — these items are within your 90-day query window but not yet within their specific lead window, so no action today.
The first action in your Yes branch is a notification to the agreement owner. This isn't the approval request — it's a heads-up email that the renewal process is starting and they need to take action.
Add a "Send an email (V2)" action from the Office 365 Outlook connector. Configure it like this:
To: items('Apply_to_each')?['OwnerEmail']
Subject: Renewal Required: @{items('Apply_to_each')?['Title']} expires @{formatDateTime(items('Apply_to_each')?['ExpiryDate'], 'MMMM d, yyyy')}
Body (HTML):
<p>Hi,</p>
<p>This is an automated reminder that the following agreement is approaching its expiry date and requires renewal sign-off:</p>
<table>
<tr><td><strong>Agreement:</strong></td><td>@{items('Apply_to_each')?['Title']}</td></tr>
<tr><td><strong>Type:</strong></td><td>@{items('Apply_to_each')?['AgreementType']}</td></tr>
<tr><td><strong>Expiry Date:</strong></td><td>@{formatDateTime(items('Apply_to_each')?['ExpiryDate'], 'MMMM d, yyyy')}</td></tr>
<tr><td><strong>Days Remaining:</strong></td><td>@{div(sub(ticks(items('Apply_to_each')?['ExpiryDate']), ticks(utcNow())), 864000000000)}</td></tr>
</table>
<p>An approval request will follow shortly. Please review the agreement documentation in SharePoint and respond to the approval when it arrives.</p>
<p>If this renewal is no longer required, please update the item status in the <a href="https://yourtenantname.sharepoint.com/sites/Agreements/Lists/OrganizationalAgreements">Organizational Agreements list</a> before responding to the approval.</p>
The days-remaining calculation — div(sub(ticks(ExpiryDate), ticks(utcNow())), 864000000000) — converts the difference in ticks (100-nanosecond intervals) to days by dividing by the number of ticks in a day. It's not elegant, but it's reliable. For a comprehensive tour of date expressions including cleaner alternatives using dateDifference where available, Mastering Dynamic Expressions and the Power Automate Formula Language: String, Date, and Array Functions for Real-World Data Manipulation is the reference you want.
After sending the notification, add an "Update item" action to set RenewalStatus to "Renewal In Progress." This is a critical step — it prevents the daily flow from processing this item again tomorrow while it's actively in an approval workflow. Without this guard, you'll send duplicate approval requests every day until someone responds.
Now comes the core of the pattern: a sequential, multi-step approval that routes the renewal through two levels of sign-off. The first approver is the agreement owner themselves (confirming they've reviewed the terms and the renewal is warranted). The second approver is the designated secondary approver — a manager, legal contact, or compliance officer depending on your organization.
Note
Sequential approvals where the first approver is the item owner and the second is a manager are common in regulated industries. The owner approval step documents that the person closest to the agreement has reviewed it; the manager step documents organizational authorization. This two-step trail satisfies most audit requirements without the overhead of a full three-stage process.
Add a "Start and wait for an approval" action. Use the approval type "Approve/Reject - First to respond" (since there's only one approver at this step, it doesn't matter, but being explicit is good practice). Configure it:
Title: Renewal Approval Required - @{items('Apply_to_each')?['Title']}
Assigned to: items('Apply_to_each')?['OwnerEmail']
Details:
Agreement: @{items('Apply_to_each')?['Title']}
Type: @{items('Apply_to_each')?['AgreementType']}
Expiry Date: @{formatDateTime(items('Apply_to_each')?['ExpiryDate'], 'MMMM d, yyyy')}
Please confirm that you have reviewed the current agreement terms and that renewal is appropriate.
Add any notes about changes to scope, pricing, or terms in the Comments field.
After your approval, this request will route to the secondary approver for final sign-off.
Item link: A direct URL to the SharePoint list item. You can construct this using the item ID: https://yourtenantname.sharepoint.com/sites/Agreements/Lists/OrganizationalAgreements/DispForm.aspx?ID=@{items('Apply_to_each')?['ID']}
The flow pauses at this action until the approver responds. This is a synchronous wait, which means your flow run stays open. For agreements with long lead times, this is fine — a 30-day wait is well within Power Automate's 30-day flow run timeout. If you're dealing with very long approval windows, see Automating Time-Sensitive Approval Escalations in Power Automate: Using Do Until Loops, Timeout Conditions, and Teams Notifications to Enforce SLA Deadlines for patterns that handle extended waits without leaving runs hanging.
After the approval action, add a Condition that checks the outcome:
outputs('Start_and_wait_for_an_approval')?['body/outcome']ApproveYes branch (approved): Proceed to Step 2 approval (secondary approver).
No branch (rejected): Update the SharePoint item — set RenewalStatus back to "Active" and append the rejection comments to RenewalNotes. Then send an email to the owner explaining that they rejected their own renewal request (which sounds odd but happens when someone realizes the agreement is being handled differently, or they want to escalate it out of band). No second approver needed.
For the rejection note update in the No branch, use an "Update item" action with RenewalNotes set to something like:
@{items('Apply_to_each')?['RenewalNotes']}
--- Renewal Attempt @{utcNow('yyyy-MM-dd')} ---
Owner declined at Step 1.
Comments: @{outputs('Start_and_wait_for_an_approval')?['body/responses'][0]['comments']}
This appends to existing notes rather than overwriting them, preserving historical context.
Inside the Yes branch of your owner approval condition, add a second "Start and wait for an approval" action. This time:
Assigned to: items('Apply_to_each')?['SecondaryApproverEmail']
Title: [Final Sign-Off Required] Renewal Approval - @{items('Apply_to_each')?['Title']}
Details:
Agreement: @{items('Apply_to_each')?['Title']}
Type: @{items('Apply_to_each')?['AgreementType']}
Expiry Date: @{formatDateTime(items('Apply_to_each')?['ExpiryDate'], 'MMMM d, yyyy')}
Owner (@{items('Apply_to_each')?['OwnerEmail']}) has approved this renewal.
Owner comments: @{outputs('Start_and_wait_for_an_approval')?['body/responses'][0]['comments']}
Your approval constitutes final organizational authorization for this agreement's renewal.
Add another Condition after this action to branch on the secondary approver's response.
Key insight
At the multi-step approval architecture level, you have a design choice between building sequential steps inside a single flow run (as we're doing here) versus chaining separate flows. The single-run approach is simpler to build and debug, and all the approval context is in scope throughout. The multi-flow approach is more resilient for very long-running processes but requires passing state via SharePoint columns between flows. For moderate SLAs (days to weeks), the single-run sequential approach wins on simplicity without meaningful risk. Designing Multi-Stage Approval Chains in Power Automate: Sequential, Parallel, and Delegated Sign-Off Patterns covers the full taxonomy of approaches including when parallel approvals make more sense.
When the secondary approver also approves, you have a complete, authorized renewal. Now execute three actions in sequence:
Action 1: Calculate new expiry date
Add a Compose action named NewExpiryDate. The expression depends on your business rules — most agreement renewals are for a fixed term (1 year, 3 years). Use:
formatDateTime(addDays(items('Apply_to_each')?['ExpiryDate'], 365), 'yyyy-MM-dd')
This calculates the new expiry as the old expiry date plus 365 days (not today plus 365 days, which is a common mistake). Renewing from the existing expiry date prevents "drift" where agreements quietly lose coverage during the approval process. If your agreements renew from the actual date of approval, change items('Apply_to_each')?['ExpiryDate'] to utcNow().
Action 2: Update the SharePoint item
Title: [unchanged — reference the existing value]
ExpiryDate: outputs('NewExpiryDate')
RenewalStatus: Active
LastRenewalDate: utcNow('yyyy-MM-dd')
RenewalNotes: [append approval summary]
The renewal notes append:
@{items('Apply_to_each')?['RenewalNotes']}
--- Renewed @{utcNow('yyyy-MM-dd')} ---
Owner approved: @{outputs('Start_and_wait_for_an_approval')?['body/responses'][0]['comments']}
Secondary approved: @{outputs('Start_and_wait_for_an_approval_2')?['body/responses'][0]['comments']}
New expiry: @{outputs('NewExpiryDate')}
Action 3: Send confirmation email to both stakeholders
Send a confirmation to both the owner and secondary approver (use the To and CC fields appropriately). The email should confirm the new expiry date, include a link to the updated list item, and serve as a record of the approval event.
If the secondary approver rejects, the situation is more nuanced than a Step 1 rejection. The owner has already approved; now you need to tell them that the secondary approver pushed back. Set RenewalStatus back to "Active" (so the daily flow can re-evaluate it tomorrow), append the rejection reason to RenewalNotes, and send a detailed email to both the owner and the secondary approver explaining the status and what happens next. Consider including a prompt to schedule a conversation — automated workflows should gracefully hand off to human judgment at impasse points rather than leaving people confused about what the system did.
Remember the second "Get items" query you set up earlier — the one fetching items where ExpiryDate is already in the past and RenewalStatus is still "Active"? Wire up a parallel "Apply to each" loop for those items.
Inside this loop, the logic is simpler but urgent:
RenewalStatus to "Expired."URGENT: Agreement Expired - @{Title}), explicit acknowledgment that the expiry has already passed, and a call to immediate action.Warning
Don't send expired items through the same approval chain as approaching-expiry items unless you've confirmed that the agreement is still in a renewable state. Some expired agreements require legal review or renegotiation before renewal — automating approval of an already-expired contract can create compliance problems. The safer pattern is to flag expired items and prompt human action, rather than auto-routing them into an approval flow that could result in a rubber-stamp renewal.
One of the most powerful extensions of this pattern is conditional routing based on the AgreementType column. A software license renewal and a data-sharing agreement renewal might have very different approval requirements — the former might need only the IT owner's sign-off, while the latter requires legal review as a mandatory second step.
After the first "Get items" and before the owner notification, add a Switch action on items('Apply_to_each')?['AgreementType']. Each case defines a different approval chain:
Case: "Software License"
Case: "Data Sharing Agreement"
Case: "Vendor Contract"
Default case: Use the standard two-step owner + secondary approver chain we've already built.
This branching logic is where the pattern moves from generic to genuinely powerful. Building a Dynamic Multi-Condition Approval Flow in Power Automate: Routing Requests to Different Approvers Based on Form Input, Dollar Thresholds, and Department Rules covers exactly this pattern in detail, including how to store approver routing rules in a configuration list rather than hardcoding them in the flow — a significant maintainability improvement for complex organizations.
The RenewalStatus column is doing a lot of work in this architecture. Let's be explicit about every state transition and why each one matters:
| From Status | Trigger | To Status | Who Sets It |
|---|---|---|---|
| Active | Daily flow, within lead window | Renewal In Progress | Flow (before first approval) |
| Renewal In Progress | Owner rejects Step 1 | Active | Flow (rejection branch) |
| Renewal In Progress | Secondary rejects Step 2 | Active | Flow (rejection branch) |
| Renewal In Progress | Both approve | Active | Flow (with new ExpiryDate) |
| Active | Daily flow, past ExpiryDate | Expired | Flow (expired loop) |
| Expired | Manual intervention | Active | Human (admin updates list) |
The state machine is intentional. Items return to "Active" after rejection rather than going to a "Rejected" or "Pending Review" status, because "Active" is what enables the daily flow to pick them up again. If you created a "Rejected" status, the daily flow would skip those items (since it only processes "Active" items), and the agreement would silently drift toward true expiry without any further automated action.
The exception is if you want to implement a "cool down" period after rejection — say, don't re-trigger the approval for 7 days after a rejection. To implement this, add a LastRejectionDate column, and modify your OData filter to exclude items where LastRejectionDate is within the last 7 days. This prevents immediate re-triggering of approvals that someone just consciously declined.
Tip
For agreements that have been in "Renewal In Progress" for longer than your expected SLA (say, 14 days), consider building a separate "stale approval escalation" flow. This scheduled flow queries for items in "Renewal In Progress" status where LastRenewalDate has not been updated in 14+ days, and sends escalation notifications. Automating Recurring Approval Reminders in Power Automate: Escalating Overdue Requests, Notifying Delegates, and Closing Stale Approvals Automatically is the companion lesson to this one for exactly that pattern.
A flow that processes business-critical agreements needs error handling. The bare minimum for production use:
Configure run-after for rejection branches. Right-click any action in your flow and select "Configure run after" to specify that an action runs even if a preceding action fails. Use this on your SharePoint update actions so that if the approval notification email fails, the status update still runs (and vice versa). Without this, a transient email failure can leave an item stuck in "Renewal In Progress" forever with no active approval outstanding.
Add a scope around each item's processing logic. Wrap the per-item logic (notification, approval, update) inside a Scope action. This lets you configure a catch block: if the Scope fails, the catch block sends an alert email to a flow administrator and updates the item with a note indicating the automated processing failed. Without this, one bad item (say, an owner email address that's been deprovisioned) will silently kill that item's processing — or worse, corrupt the item's status.
Log outcomes to a separate audit list. After each approval completes (successfully or not), write a record to a separate "Renewal Audit Log" SharePoint list with the item ID, outcome, timestamp, and approver responses. This decouples your audit trail from the working data in the main list. Master Error Handling and Retry Patterns in Power Automate for Bulletproof Flows covers the full scope of resilience patterns including parallel error branches and retry logic for transient connector failures.
Build this flow in a test environment against the SharePoint list you created earlier. Work through it in stages:
Stage 1 (30 minutes): Create the SharePoint list with all columns. Populate 5 test items:
Build the scheduled flow with the recurrence trigger. Add only the "Get items" action and a Compose to output the returned items. Run it manually (using the Test button). Verify: Item A and Item D come through. Item B, C, and E should not (B is outside the 90-day window — wait, B is at 60 days which is inside 90, so it will come through the OData filter. This is intentional — the per-item condition filters it out). Item C is filtered out by the RenewalStatus eq 'Active' OData filter. Item E has 14-day lead days, so the alert threshold is today + 14, and ExpiryDate is today + 25 — the per-item condition evaluates as false. Only Item A should trigger the full approval chain.
Stage 2 (45 minutes): Add the "Apply to each" loop with the per-item condition and the owner notification. Run again manually. Verify that only Item A generates an email, and the email contains correct date values.
Stage 3 (45 minutes): Add the two-step approval chain. Use your own email for both approver fields in testing. Run the flow, approve both steps, and verify: Item A's ExpiryDate updates to one year later, RenewalStatus returns to "Active," LastRenewalDate is set to today, and RenewalNotes contains the approval summary.
Stage 4 (20 minutes): Test the rejection path. Run the flow again (temporarily reset Item A's status to "Active" and move ExpiryDate back). When the first approval arrives, reject it. Verify: RenewalStatus resets to "Active," RenewalNotes contains the rejection reason, and no second approval is sent.
Stage 5 (20 minutes): Wire up the expired-items loop. Verify Item D receives the urgent email and its status changes to "Expired."
"The flow processes the same item every day even though it's already in Renewal In Progress."
You have a gap in your OData filter. Check that you're filtering on RenewalStatus eq 'Active' and that the SharePoint column is a Choice type (not text). If it's Choice, the OData filter must match the exact case of the choice value. "Active" ≠ "active" in OData.
"Date comparisons aren't working — items near the boundary aren't being caught."
This is almost always a time zone issue. utcNow() returns the current UTC time, while your SharePoint list's ExpiryDate column stores dates as midnight UTC. If your flow runs at 7 AM UTC+10 (meaning 9 PM the previous day in UTC), utcNow() is still showing yesterday's date. Either run your flow at a time where UTC matches your business intent, or convert utcNow() to your local date using convertTimeZone(). See Scheduling and Managing Time-Based Flows in Power Automate: Recurrence Triggers, Time Zones, and Business Hours Logic for a thorough treatment of this.
"The 'Start and wait for an approval' action times out after 30 days."
Power Automate flow runs have a 30-day maximum duration. If your secondary approver takes more than 30 days (which shouldn't happen in a well-designed process, but does), the run expires and the approval hangs. The mitigation is to set an approval expiry using the "Due Date" field in the approval action — set it to something like addDays(utcNow(), 7). When the approval expires, it auto-rejects, and your rejection branch should handle re-notification. Pair this with the escalation pattern from Automating Time-Sensitive Approval Escalations in Power Automate: Using Do Until Loops, Timeout Conditions, and Teams Notifications to Enforce SLA Deadlines.
"The approval action says the approver doesn't exist or can't receive approvals."
The email address in the "Assigned to" field must be a valid Microsoft 365 user in your tenant. If you're using a Person column in SharePoint, extract the email with items('Apply_to_each')?['OwnerEmail/Email'] (note the /Email suffix for Person columns). If you're using a text column, make sure the value is a proper UPN (usually the same as the email address in M365).
"The new ExpiryDate is calculating incorrectly — it shows today's date plus 365, not the original expiry plus 365."
You've used utcNow() in your Compose expression instead of items('Apply_to_each')?['ExpiryDate']. They look similar in the expression editor when you're moving fast. Double-check the Compose action for NewExpiryDate and verify the base date is the item's existing ExpiryDate value.
"The 'Apply to each' loop runs but takes forever and I can't tell which item is failing."
Turn on "Concurrency Control" in the "Apply to each" action settings and set degree of parallelism to 1 (sequential) during testing. This slows it down but makes the run history much easier to read since items process one at a time in order. Once you've validated the logic, you can increase parallelism — but be cautious: parallel approval chains can hit connector throttling faster than sequential ones. Check the run history with Using Power Automate Run History and Flow Checker to Debug and Fix Failing Flows to trace which item caused the issue.
You've built a complete, production-ready recurring approval workflow that:
This pattern is a foundation. The real-world extensions that most organizations layer on top include:
Agreement type routing — using a Switch action to route different agreement categories through different approval chains, as described in the routing section above.
Delegation handling — if the designated owner is on leave, their approval should route to their delegate. This requires either a delegation column on the SharePoint list or integration with Microsoft Graph to look up out-of-office settings dynamically.
Teams adaptive card approvals — replacing email-based approvals with Teams adaptive cards that display the full agreement context inline and allow approvers to respond without leaving Teams. This dramatically improves response rates. Implementing Adaptive Card-Based Human-in-the-Loop Approvals in Power Automate: Dynamic Forms, Contextual Data Injection, and Response Handling is the next lesson to work through.
Integration with document libraries — linking each list item to a SharePoint document library where the actual agreement document lives, and including a rendered preview or summary in the approval notification. Power Automate with SharePoint: Automate Document Approvals covers the document-centric patterns.
The organization that builds this system stops losing agreements to silent expiry. More importantly, it creates a documented, auditable record of every renewal decision — who approved it, when, with what comments. That's not just operational hygiene; for many regulatory environments, it's a requirement. Build it once, and it runs every morning without anyone having to remember to check a spreadsheet.