Article 23. Algorithmic System Integrity: Testing

Spoken by a human version of this article.

TL;DR (TL;DL?)

• Testing is a core basic step for algorithmic integrity.
• Testing involves various stages, from developer self-checks to UAT. Where these happen will depend on whether the system is built in-house or bought.
• Testing needs to cover several integrity aspects, including accuracy, fairness, security, privacy, and performance.
• Continuous testing is needed for AI systems, differing from traditional testing due to the way these newer systems change (without code changes).

About this podcast

A podcast for Financial Services leaders, where we discuss fairness and accuracy in the use of data, algorithms, and AI.

Hosted by Yusuf Moolla.
Produced by Risk Insights (riskinsights.com.au).

Episode Transcript

Yusuf (00:00):
This article was published in February 2025.
It's titled Algorithmic SystemIntegrity Testing.
There's no specific orparticular point of view
expressed in this article.
It is just one of those reallyimportant things and is a core
basic step that we all need totake and so tries to sort of

(00:21):
that need to be considered.
So here we go.
In reviewing algorithmic systemsfor integrity, we often consider
how the systems are tested andwhat the quality assurance
process is.
Testing and quality assurance gohand in hand, with testing
generally considered a subset ofoverall QA.

(00:44):
Testing is a core component ofchange control.
It helps ensure that algorithmsfunction as intended.
Why testing matters?
If you're reading this, youprobably, if you're listening to
this, you probably already knowwhy you need to test.
In brief, Testing helps identifyerrors before systems are put
into production, saves time andresources, fixing issues in live

(01:08):
systems is often costlier andmore complex.
Increases confidence in systemflows and outputs, and is needed
to meet regulatory obligations.
This could either be explicit,so for example CBS 234 in
Australia is explicit abouttesting, or implicit.
those include GDPR, HIPAA andmany others.

(01:30):
Testing stages.
Before we explore the keytesting stages, there are three
important points to note.
Some testing may be manual,Others could be automated.
Continuous testing may benecessary, especially for AI
systems.
This differs from traditionalsystems where testing may only
be needed for new applicationsor changes.

(01:52):
And this is because the modelschange without changes to code.
So for example, new data inputsresult in model drift, etc.
And the third important point tonote, if you're buying software
rather than building it, Theearliest steps will be performed
by the vendor, so check how thisis done, check that this is
done, and how this is done.

(02:12):
UAT, so user acceptance testing,at a minimum, will fall within
your team.
So here are the stages.
This is not a comprehensivelist, but it covers most core
stages.
Unit testing or developer selfchecks.
This is where developers performinitial code or flow reviews.

(02:34):
Tests on individual componentsor functions of the algorithmic
system.
catch basic errors early in thedevelopment process.
Then we have peer review.
This is where colleagues reviewthe code and test results,
providing a fresh perspectiveand potentially finding issues
the developer might have missed.
The third stage, technicalreview.

(02:56):
A more experienced team memberevaluates technical aspects,
ensuring it meets architecturalstandards and performance
requirements.
This may also involve otherteams to conduct non functional
testing.
So, for example, certainsecurity related testing if it's
not covered elsewhere.
The fourth stage, functionaltesting.
A non technical team memberensures the system meets the

(03:19):
intended functionalrequirements.
And then finally, businesstesting, also known as user
acceptance testing or UAT.
So this is where end users orbusiness stakeholders test the
algorithm in a real worldcontext.
This is to ensure that it meetstheir requirements and functions
as expected.
And this, ideally, uses realdata across a variety of

(03:40):
scenarios.
Let's talk about testing acrosssome of the key integrity areas.
So, effective testing shouldaddress multiple aspects of
algorithm integrity, andexamples of those, or examples
of the core aspects includeaccuracy, fairness, security,
privacy, and performance.
With accuracy, we want to verifythat the algorithmic system

(04:02):
produces correct, that'scomplete, and valid, and
accurate.
outputs or results.
So for example, we test thesystem using known inputs and
expected outputs across variousscenarios.
When we're testing for fairness,we're evaluating the system for
bias against protectedattributes, looking for
unintended discriminatoryoutcomes.

(04:23):
For example, if the system nowuses free text fields beyond
structured data, protectedinferred.
Another aspect is security.
So this is where we assessvulnerabilities, making sure
that existing controls are notinadvertently bypassed.
For example, we check thatsecurity controls for

(04:44):
authentication still work,especially if there are
workarounds in place.
Privacy, We check thatconfidentiality is maintained
and that sensitive data isprotected.
So for example, we verify thatthe algorithm doesn't reveal
sensitive data through itsoutputs.
And then performance.
Here we measure efficiency andscalability.

(05:05):
For example, simulate highvolume scenarios to ensure the
algorithm works under peakloads.
So, all in, this is a basic butimportant set of steps towards
algorithm integrity.
A testing strategy that coversvarious aspects can
significantly enhance algorithmintegrity, ensuring the systems
are not only technically sound,but also fair, secure, and

(05:27):
aligned with businessobjectives.
That's the end of the article.
Thanks for listening.