.png?width=200&height=200&name=dovetail%20workmarklogo%20(1).png)
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.
Where Power Automate picks up
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.
What needs a flow rather than a rule
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 |
Before you start
A few things need to be in place before to get the most from the flow:
- The Autofill columns from Part 1, populating reliably across a varied sample. The flow can only act on what those columns hold.
- A Risk column stored as a Choice column (for example, High, Medium and Low). A fixed set of values makes the later condition a clean equals check. Free text is far harder to match on.
- The destination folders already created in the library, such as High Risk, Medium Risk and Low Risk.
- Permission to create flows, and a check on licensing. Some connectors and actions need a premium Power Automate plan, so confirm against your own tenant rather than assuming.
- Access to make.powerautomate.com, where you build and manage flows.
Building the routing contract 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.
1. Trigger: when a file is created or modified
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.
2. Add a delay
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.
3. Get file properties
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.
4. Add a Compose step
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.
5. Add the first condition
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.
6. Handle the remaining ratings
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.
Why Column type matters here
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.
Seeing it work
Once the flow is on, a quick test shows the whole thing running on its own:
- Drop a high-risk contract into the library.
- Refresh and watch the columns populate first. Nothing has moved yet, because the delay is still running.
- Wait for the flow. The file moves itself into the High-Risk folder.
- Check the mailbox. The alert has landed.
Nobody triaged that contract. SharePoint automatically read it, rated it and filed it.
Closing the loop with Outlook
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:
- Trigger: When a new email arrives, pointed at that Outlook folder, with attachments turned on.
- Apply to each, passing in the attachments, so the flow handles every file on the email.
- SharePoint Create file, pointed at the contract's library.
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.
The flow, end to end
As a recap, here’s a summary of the full sequence:
- A contract arrives by email. You drag it into an Outlook folder.
- A flow uploads it to the SharePoint library.
- Autofill reads it and fills in the parties, the value, the renewal date and the risk.
- A second flow reads the risk and files the contract in the right folder.
- If it is high risk, the right person gets an email the same day.
Five moving parts, and the only one that needed a person was the drag into a folder in outlook.
Other flows worth considering
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 |
Common issues to check
Everything files as low risk
- 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.
The flow runs in a loop
- 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
The condition never matches
- 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.
The flow does not fire at all
- Confirm the trigger points at the correct library and folder, and that the flow is switched on.
The email never arrives
- Check the recipient in the Send an email step and check the junk folder.
What nobody tells you about Workflows
The delay step in the flow is important
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.
A choice column is what makes the whole thing reliable
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.
Build one flow that earns trust before you build ten
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.
Moving a file is an action with consequences
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.
See what this could look like for your contracts
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.
Wrapping up
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
