Your board wants more assurance. It also wants the cost of control to go down. For most risk teams, those two asks pull in opposite directions: more assurance usually means more testing, and more testing means more hours and thus more cost.
At our user conference in September, Maurits Toet, COO of CERRIX, put a number on that tension. He walked through a business case for control framework optimisation and automation, built on what we see across our client base. The short version: an average mid-sized client spends over half a million euros a year just running and testing its controls. More than half of that can be saved, while assurance increases.
Here is how the case is built, so you can run the numbers for your own framework.
Why the cost of control keeps rising
Control frameworks continue to grow, mainly driven by increasing regulatory pressure. Every new regulation adds controls, and few get removed. We have clients running more than 2,000 controls in a single company.
Most of those controls are still performed and tested manually. Because controls are executed and tested again and again, that cost adds up fast. Manual control execution also takes time away from your employees' core activities. And because people are only human, the outcomes can be biased.
For testing, one employee usually pulls data from a system or file and puts it into the GRC system. Another employee then compares that data against a test activity plan and records a test score. Finally, the second line reviews the process.
Another factor adding to the bill is the cost of personnel, which goes up every year. The people who execute and test controls cost considerably more than they did a few years ago.
What makes it hard to change is that nobody sees the actual cost of control. Very few organisations know what their controls cost to run and test, so the cost of control never makes it onto the board agenda and nothing really changes.
The hard conclusion is that all that effort and cost buys less assurance than it should. Testing happens after the fact: if a control failed in January and you test Q1 in April, you are three months late with your remediation. You know it went wrong, but you are simply too late, and you have been exposed to the risk for a prolonged period of time.
What you need is greater and faster insight: more assurance at less cost.
What control costs an average client today
An average CERRIX client spends around €528,000 a year running and testing its controls. That client has 100 to 250 users, 30 to 50 processes, 5 to 10 frameworks, 100 to 250 risks and 500 controls, of which 250 are key controls.
The assumptions behind the number are deliberately simple, and you can argue with every one of them:
- Number of key controls versus supporting controls (in this case 250 key and 250 supporting controls)
- Employee cost per hour (in this case €60)
- Percentage of controls executed manually (in this case 80%)
- Average execution frequency (in this case 6 times a year)
- Duration of a control execution (in this case 2 hours)
- Number of design and implementation (D&I) tests a year (in this case one per control)
- Duration of a D&I test (in this case 1 hour)
- Which controls are tested for effectiveness (in this case the key controls)
- Average number of effectiveness tests a year (in this case 4)
- Duration of an effectiveness test (in this case 3 hours across all roles, based on sampling)
- Percentage of tests that fail (in this case 20%)
- Time for remediation and retesting (in this case 1 hour after a failed D&I test, 2 hours after a failed effectiveness test)
Two things stand out. Control execution is the biggest line by far, more than half the total. And a single effectiveness test takes longer than executing the control it tests.
Now imagine you could cut that number in half. Would your board be interested?
Lever 1: optimise your control framework
The first lever is the framework itself: fewer controls, and fewer of them executed and tested manually.
Start with what you have. Many frameworks carry controls that are really process steps or actions. Clearing those out is often the quickest win, and it lowers the base for everything that follows.
Focus on preventive controls. A preventive control stops a risk before it happens, instead of detecting or repairing the damage afterwards. Get the preventive control right and you often need fewer controls behind it.
At a bank, automated screening of new customers against a sanctions list is a good example. It stops the wrong customers from getting in, instead of having to remove them later. It is also easy to set up: the system checks the customer's details against the list and returns a result.
Move from manual controls to application controls. When a process step runs inside an application, the control can run there too. That pays off twice:
- You remove the manual execution, which is the biggest cost line.
- An application control behaves the same way every time. You still test its design and implementation, but you no longer need periodic effectiveness tests on a sample.

Take a four-eyes check in an insurer's claims process. Of the 30 minutes one check takes, around 25 go into collecting documents and matching them against each other. Only the last 5 are the actual review. Automate the collecting and matching, and the reviewer spends their time on the part that needs judgement. At thousands of claims a year, that adds up fast.
This does take an upfront investment. Costs go up briefly before they come down. If your source systems already have APIs, that investment is a lot smaller.
Lever 2: optimise your testing cycle
The second lever is how, and how often, you test. This is where cost goes down and assurance goes up at the same time.
Test based on risk exposure. Instead of testing every control, focus on the controls that cover your highest risks and prevent those risks from occurring. Add a higher/lower frequency model: a control that tests effective three times in a row can be tested less often. One that keeps failing gets tested more.
Test the population, not a sample. Once testing is automated, there is no reason to stick to a sample. Take a control that says every incident must get a first response within a set time. A script compares the time each incident was logged with the time of the first reaction, for every incident in the quarter. You set the norm, say 95% on time, and the result tells you whether the control is effective.
The same logic works for a legal deadline, such as reporting a data breach to your data protection authority within 72 hours under GDPR. The only difference is that you don't set the norm yourself: it is 100%.
Because the data comes straight from the source system, there is less room for error and less room for bias. You are no longer asking a colleague to send a screenshot.
Find exceptions while they still matter. Automated testing flags an exception close to the moment the control ran, not a quarter later. The evidence is collected at the source, the exception goes to the owner, and the tester reviews outcomes instead of assembling samples. Run it often enough and you are close to continuous assurance.
Look for patterns in the exceptions. If the same exception keeps coming back, AI can help spot the pattern, so remediation goes after the cause rather than the symptom. Is it a training issue, or is the process itself broken? A person still judges what the exception means and signs off on the result.
The same year, after optimisation
Apply both levers to the same client and the yearly cost of control drops from €528,000 to €225,600. That is €302,400 saved, or 57%.
The model takes two steps. First, the framework goes from 500 to 400 controls; the 100 controls removed are all non-key, so the 250 key controls remain. Then automation goes from 20% to 60% of all controls, key controls included. Automated controls only need a D&I test, so 100 manual key controls are left for effectiveness testing. Same client, same €60 an hour.
Where does the saving come from? Cutting the framework from 500 to 400 controls saves €64,800, mostly on execution and D&I testing. Automation does the rest: €237,600, or almost 80% of the total savings. Fewer manual executions save €115,200. Automated key controls no longer need periodic effectiveness tests, which saves another €108,000. The model doesn't count the time saved by automating the remaining tests themselves, so on that point it is conservative.
When does it pay for itself? The saving recurs every year: €25,200 a month. That is the figure your investment has to earn back. Invest €75,000 and you break even in about 3 months. At €125,000 it takes about 5 months, at €200,000 about 8.
The saving also frees up 5,040 hours a year. Most control execution happens in the first line, so a large share of those hours goes back to the business: time for customers and commercial goals instead of collecting evidence. Your risk managers get time back too, for analysis and for working with the business on the risks that matter. The model doesn't count what those hours are worth, so the real benefit is larger.
This is an illustrative model, not a promise. Its purpose is to show how a business case for optimisation and automation can be set up, and to make you ask: have we ever actually calculated this?
Where to start: one control that hurts
Don't try to automate your whole framework at once. Pick one control that covers a relatively high risk and costs a lot of manual time today. Automating that one creates the most value per euro, and it gives you more assurance exactly where you need it.
Good candidates are often found in finance, where many controls are still reconciliations in Excel: compare list A with list B and check that the ledger matches. Joiners and leavers processes are another. If the outcome of a control is black or white, it is usually a strong candidate for automation.
In a recent session with a client, we showed what that looks like in practice. Evidence for a control was pulled straight from SharePoint via an API into CERRIX. The execution was created automatically, missing evidence was flagged, and the result moved on to the next testing step.
Be honest about the costs on the other side of the case:
- Set-up and development. A one-off cost that depends on your systems and the interfaces they offer.
- Maintenance. Automation is not set and forget. When an application, process or data field changes, the automation has to change with it, and someone needs the knowledge to do that.
- Access. A connection should respect your roles. Risk and compliance may need data that the first line should not see.
- Data structure. Automation struggles when information sits in loose spreadsheets or isn't linked to your framework. Processes, risks, controls and evidence need to be connected first.
A pilot on one control lets you measure all of this for real: time saved, how exceptions are handled, and what it costs to keep running.
Build your own business case
The numbers above are ours. Yours will differ, and that is the point. To build a case your CFO and CRO will take seriously, collect the same figures for your own organisation, using the assumptions under “What control costs an average client today”.
Even a rough first pass tends to surface a number nobody had on the radar. Then the question changes from “can we afford to automate?” to “can we afford not to?”
Lower cost is what gets this case past your CFO. Higher assurance is what makes it worth doing. Instead of a sample tested a quarter after the fact, you get evidence on the full population, close to the moment each control runs. You know sooner whether you are in control, and you can show it to your board and your supervisor.
What does your control framework cost to run?
Most organisations have never calculated it. Our Professional Services team runs the numbers with you, using your own controls, test frequencies and hourly rates. You'll see what you spend today, where the savings are and which control to automate first.
Leave your details and Maurits Toet (COO) or Dart Stas (Consultant, Power BI and automation) will get in touch to plan a session.


.png)
.png)
.jpg)
.jpg)
.avif)




.jpg)
%20(1).png)
.jpg)
%20(3).jpg)

.jpg)
%20(1).jpg)
.jpg)
.jpg)
.jpg)
.jpg)
%20(1).jpg)
.jpg)
%20(1).jpg)
.jpg)
.jpg)

.jpg)
.jpg)




.jpg)
%20(2).jpg)
















%20(1)%20(2).jpg)





.jpg)

.png)
.jpg)






%20(1).avif)



