Part 3 of our three-part guide to automating contract management in SharePoint
A SharePoint rule can tell you a contract is high risk. It cannot move that file into the right folder, wait for the data to land before it acts, or deal with five contracts arriving on a single email. Those jobs need Power Automate.
By the end of Part 2, your library could react to one change and notify one person. That handles more than most people expect, but it runs out of road quickly. This guide picks up where rules stop. You will walk through a working flow that reads a contract's risk rating, files it in the right folder and emails whoever owns that contract. Then you will connect Outlook, so contracts that arrive in your email can be manually uploaded by you and sent straight to the contract library.
One thing is worth saying up front. None of this reads the contract. The flow reads the columns that Autofill populated back in Part 1 and acts on the values it finds there. That is the thread running through the whole series.
Part 1 used Autofill to pull renewal dates, parties, values and risk out of documents and store them as SharePoint metadata. Part 2 used a rule to watch one of those columns and send a notification when it changed. Rules are intentionally simple: one trigger, one action, no branching. The moment you need the library to make a decision, wait for something, or do more than one thing, you have reached the edge of what a rule can do.
There's a Workflows option inside SharePoint, but it only goes so far.
You get a handful of templates and one thing happening after another. Power Automate is where the real logic lives. A flow can pause, check several conditions, move files, post messages and run steps in sequence. Because Autofill has already turned the contract into structured columns, the flow works with clean values rather than trying to interpret the document itself.
If your process only needs a single alert, stay with a rule, it is simpler to build and easier to manage. Use Workflows when the process has steps.
| What you want to happen | Rule | Workflows |
|---|---|---|
| Notify one person when a value changes | Yes | Yes |
| Move a file into a folder based on its risk | No | Yes |
| Wait for Autofill to finish before acting | No | Yes |
| Check several conditions before deciding | No | Yes |
| Start an approval | No | Yes |
| Post to a Teams channel | No | Yes |
| Remind the owner 90, 60 and 30 days before renewal | No | Yes |
A few things need to be in place before to get the most from the flow:
This is the flow that does the real work. It watches the library, waits for Autofill to finish, reads the risk rating and files the contract accordingly. Build it step by step. The order of the steps matters more than any single one of them.
Point the trigger at your contracts library. Modified matters as much as created, because Autofill writing a value into a column counts as a modification. That is what wakes the flow up once the extraction finishes.
This is the single most important step in the flow, and the one that catches almost everyone. Autofill takes a minute or two to populate the columns. If the flow reads them straight away, it reads nothing, and every contract gets filed as low risk because the risk column was still empty when it looked. A short delay gives Autofill time to finish before anything else runs.
Now read the file again. With the delay done, the columns have values, and this step pulls the current risk rating along with anything else the later steps need.
Drop the risk value into a Compose action. It does nothing to the contract. It simply shows you exactly what came back from the column when you look at the run afterwards. When a flow misbehaves, this is the first place you check, and it saves a lot of guessing.
Create a condition that checks whether Risk is equal to High. If it is true, add two actions: Move file, sending it to the High Risk folder, and send an email to whoever owns contract risk. This is the branch that matters most, so it goes first.
Add a second condition for Medium, moving those files to the Medium Risk folder. Anything that is neither High nor Medium falls through to Low, so its move action files it in the Low Risk folder. Three ratings, three destinations.
The flow never reads the contract. It reads the metadata held in the risk column, the Autofill in the column already extracted the required information.
This flow works because Risk is a Choice column with a fixed set of values.
The condition is a simple check: is this value equal to High, yes or no. If risk were stored as free text, the same check would be fragile. A stray space, a lower case letter or a slightly different wording would slip past the condition and send the file to the wrong place. When you know a column will drive automation, a structured type earns its keep.
Once the flow is on, a quick test shows the whole thing running on its own:
Nobody triaged that contract. SharePoint automatically read it, rated it and filed it.
There is one obvious question left. If contracts all arrive by email, how do they get into the library in the first place? This is where the whole series joins up.
Make a folder in Outlook by right clicking the mailbox and give it a name like “Contract Intake”. Then build a second, short flow:
While you can automate picking up all contracts that arrive in a mailbox we recommend keeping a human in the loop for contract intake to ensure that the correct version of the contract is processed. But if your use case needs it, you could automatically act on all emails received into a mailbox.
Drag one email into a separate folder in outlook. Everything after that happens without you.
As a recap, here’s a summary of the full sequence:
Five moving parts, and the only one that needed a person was the drag into a folder in outlook.
Once you have one flow working, it becomes much easier to spot other jobs that could run in the background too. A few useful ones:
| Flow | What it does | Why it helps |
|---|---|---|
| Renewal reminders | Checks daily for contracts renewing in 90, 60 and 30 days and emails the owner | Stops renewals slipping because nobody was watching the date |
| Weekly digest | Sends a summary of everything that landed that week and how it was rated | Gives the team visibility without anyone compiling a list |
| Teams alert | Posts to a channel when a high value contract arrives | Puts the important ones where people already are |
| Approvals | Routes high risk contracts to a named person to sign off before they go further | Adds a human checkpoint where it matters |
| Calendar sync | Copies renewal dates into a shared calendar | Surfaces deadlines in a tool people already use |
| Gap flagging | Flags any contract where the value or renewal date came back blank | Turns missing data into a task rather than a surprise later |
- The delay is too short. The flow is reading the risk column before Autofill has populated it, so the value is empty, and every contract falls through to low. Lengthen the delay.
- Moving a file counts as a modification, which can re-trigger the flow. Point the trigger at a single folder rather than the whole library or add a condition that skips files already sitting in a risk folder
- Check the Compose output for trailing spaces or odd casing. Choice columns sometimes need the Value property rather than the column itself, so the comparison is made against the right thing.
- Confirm the trigger points at the correct library and folder, and that the flow is switched on.
- Check the recipient in the Send an email step and check the junk folder.
It is tempting to remove it, because nothing appears to happen while it runs. Removing it is exactly how you end up with every contract filed at low risk. Timing is part of the logic, not an afterthought.
The flow feels clever, but the reliability comes from Part 1. Because risk is a fixed set of values, every condition is a clean yes or no. Structure the data well and the automation almost writes itself.
The routing flow is the one that removes real work. Get that running and trusted first. Extra flows only help once the first one has proved the pattern.
Because a move counts as a modification, flows can trigger each other in ways you did not intend. Map what triggers what before you add the third or fourth flow.
The examples in this series focus on contracts, but the same approach works anywhere people spend time digging through documents, chasing updates, or moving information from one place to another.
Across this series, we've taken a contract from being a document sitting in a library to something SharePoint can work with.
First, Autofill pulled out the information and stored it as metadata. Then rules used that information to notify the right people when something changed. Finally, Workflows took those same values and turned them into actions, routing files, sending alerts, and handling the process automatically.
The important part is that each step builds on the last. The flow isn't reading the contract. The rule isn't reading the contract. They're both working from the information that SharePoint already extracted and stored in the library.
Once that information exists as metadata, you can search, filter, report on, alert and automate around it.
That’s the whole point.
SharePoint can organise it, notify the right people, and automate the next steps.
Every organisation's process is a little different, but the goal is usually the same: less manual work and better visibility of what's going on.
Part 1: How to automatically extract document metadata using SharePoint Autofill
Part 2: How to automate document alerts using SharePoint rules
Want to see what this could look like in your SharePoint environment?
Book a call and we'll walk through some real examples