Our Story
We built it three times. The third time, we built it our way.
It started with a question
Back in 2020, Mark noticed something that seemed surprisingly obvious.
Properties were being inspected for their condition, but nobody seemed to be systematically checking whether the things inside them actually worked.
A property might look perfectly fine, but what about the tap that didn’t work? The socket that was dead? The light that wouldn’t come on? The appliance that wasn’t functioning?
Things could be missed.
Mark thought there had to be a better way.
He started carrying out service surveys of properties. But as the properties got bigger, he needed help.
Enter John.
John and Mark already knew each other. They had worked back-to-back in a large open-plan office, although in completely different departments.
Their backgrounds were very different.
Mark’s family are tradespeople, so he’d grown up around practical work and understood how properties and trades actually operated.
John’s background was in software development and business analysis. His job had been to listen to people explain how their businesses worked, understand what they needed and turn those requirements into workable systems.
That combination would prove useful.
Before joining Mark on the surveys, John wanted to understand what a proper service survey should actually cover.
So he spoke to 12 different tradespeople.
He asked them a simple question: “What would you check?”
Their answers became the basis of a checklist.
Then John went out with Mark and started doing the surveys.
And that’s when the office background disappeared pretty quickly.
Some of the properties were, frankly, nightmares.
On one particularly memorable job, John found himself in a hazmat suit, standing outside a property wondering what exactly he’d signed up for.
Mark’s answer was simple:
“Suck it up, John.”
And in they went.
John in Hazmat
Then we discovered another problem
The surveys were working.
But the software available to carry them out and produce the reports wasn’t.
The interfaces were restrictive.
The reports weren’t how John and Mark wanted them to look.
And the more surveys they carried out, the more obvious it became that the software was forcing the work into its own structure rather than adapting to the way people actually worked.
So they decided to build something themselves.
Version 1 — We built it to solve our own problem
The first Brightchecker app was built with the help of a developer.
It was a big step forward.
But using it in the real world quickly exposed its limitations.
Each inspection element was limited to four photographs or a video.
That simply didn’t reflect reality.
Some things need one photograph.
Some need ten.
Sometimes you need video.
Sometimes you need something completely different.
So we went back to the drawing board.
Version 2 — We listened
The second version introduced a much more flexible approach to report layouts.
But it also taught us something important.
The interface had three layers:
Section → Item → Questions
It made sense technically, but users told us they wanted something simpler.
They wanted two layers, not three.
They wanted quicker interfaces.
They wanted to build their own custom templates more easily.
And they wanted reports to be easier to create and manage.
So we simplified it.
We also discovered another frustration.
Inspection templates had to be manually attached to report layouts every time.
It worked, but it was another unnecessary step.
Version 2 was better.
But it was still experimental.
We were learning what genuinely flexible inspection software needed to be.
Then people started noticing
We took the app to trade shows.
We demonstrated it to people in the industry.
We met inspectors and businesses who could see what we were trying to achieve.
They loved the look of it.
They loved the idea.
They could see the promise.
And they started telling us what they wanted it to become.
That feedback mattered.
Because by this point, we were beginning to realise that we weren’t simply building another inspection app.
We were learning how inspection software should work.
Version 3 — We built it our way
Eventually, John and Mark decided that if they were going to build the software they really wanted, they couldn’t keep compromising around the limitations of earlier versions.
So this time:
We built it ourselves.
When someone who had used Version 2 saw Version 3, their reaction was:
“It’s a completely different beast.” and “Its obvious you’ve poured your heart and sole into it”
They were right.
Version 3 wasn’t simply another iteration.
It was a new framework.
We stopped thinking only about the inspection
By then we’d realised something important.
The inspection itself isn’t the differentiator.
Everyone needs to capture information.
Everyone needs questions.
Everyone needs photographs.
Everyone needs reports.
An inspection survey should do what you expect it to do.
It’s everything around the inspection that can change how a business works.
So Version 3 was designed around sharing the work, managing the workflow and connecting everything together.
Reports could become interactive web reports and PDFs.
Information could be shared through links.
Clients could be given access through a client portal.
The inspection wasn’t simply the end of the process.
It became the beginning of what happened next.
We made the workflow visual
Version 3 introduced a very different way of working with the process.
Surveys, Reports and Actions each have their own visual workspace.
The workflow stages are represented by simple traffic-light colours.
But the lights aren’t just there to show you what’s happening.
They’re controls.
The colour tells you where something is.
The stage tells you where you are in the workflow.
Click the current stage and Brightchecker gives you the relevant contextual command.
Click a previous stage and the available action changes.
You can move the work forward.
You can reverse it.
You don’t need to stop and work out which menu you need.
See it.
Click it.
Keep moving.
The aim was simple:
Make the right action feel instinctive.
We gave every property its own command centre
Version 3 also changed the way we thought about the property itself.
Every property can have its own Property Command Centre.
Property Command Centre Screen
Address.
Building photographs.
Maps.
Access information.
Everything the team needs to know about that property.
But it isn’t simply somewhere to store information.
From there, you can start a survey for the property.
You can also see the reports associated with it.
The property becomes the thread connecting everything together:
Property → Surveys → Reports → Actions
We let businesses define their own rules
We also didn’t want Brightchecker telling every business there was only one correct way to work.
Version 3 allows users to create their own business rules.
Those rules can determine when issues are triggered during an inspection.
Then, back at base, the business decides what happens to those issues.
Review them.
Assign them.
Action them.
Resolve them.
The software supports the process.
The business defines it.
We built it to share the work
The information captured during an inspection shouldn’t be trapped inside the inspection software.
That’s why Version 3 supports interactive web reports and PDFs, links to information and a client portal.
The report isn’t necessarily the end product.
It can become part of the wider process — something people can access, share, review and act upon.
Because that’s what we had come to understand:
The inspection is only the beginning.
And then AI arrived
Version 3 wasn’t designed to be finished.
It was designed as a framework that could keep evolving.
An example of that is the integration AI into the platform.
These aren’t features added simply because AI is fashionable.
They’re part of the same philosophy we’ve had from the beginning:
If something can make the process simpler, faster or more useful, we want the framework to be able to accommodate it.
So, are we finished with Version 3?
No.
And that’s the point.
Version 3 isn’t the final version of Brightchecker.
It’s the framework that allows us to adapt and grow the software without starting again every time we discover a better way of doing something.
We’ve built it three times.
Each time, we learned something.
From the properties.
From the tradespeople.
From the people using the software.
From the people we met at trade shows.
And from our own mistakes.
Version 1 showed us the limitations.
Version 2 showed us what users really wanted.
Version 3 gave us the framework to keep building.
And we’re still building.
We still care about properties
There’s a reason we continue to write about properties.
Sometimes we write with Brightchecker in mind.
Sometimes we don’t.
Sometimes we simply write about something because we care about properties and everything around them.
Our interest in properties didn’t start with Brightchecker, and it didn’t stop when we built the software.
We still care about the people who live in them, work in them, inspect them, maintain them and manage them.
Because that’s where this whole journey started.
Not with software.
With properties. And everything around them.
And perhaps that’s the simplest way to understand Brightchecker.
We don’t just want to help you carry out an inspection.
We want to help you change what happens around it — and ultimately change the way your business works.
The inspection is only the beginning.
About the Author
