The Problem
A residential neighbourhood was struggling with a fundamental trust problem,residents didn’t know if their payments were being recorded correctly.
The accounting was managed through Xero, but the setup had accumulated anomalies over time. Missing invoices, incorrect reconciliations from manual human entry, unreconciled accounts, houses with unclear outstanding balances. Nobody had a clear picture, not the management, not the residents.
The result? People stopped paying. Not necessarily out of bad faith, but out of confusion and distrust. Why pay if you’re not sure it’s recorded? Why chase an invoice you’re not sure exists?
Collection rate was sitting at around 20%. Meaning 8 out of 10 households were not paying.
The Insight
The obvious assumption was that the problem was people refusing to pay.
The real problem was that nobody could confidently verify anything.
- Residents couldn’t confirm their payment was received
- Management couldn’t cleanly identify who truly owed what
- The accounting data itself was unreliable, missing invoices created gaps
This reframed the entire solution. It wasn’t a collections problem. It was a trust and visibility problem.
The Approach
Rather than building a feature rich platform from scratch, the work started at the foundation, fixing the data.
Every house account was audited. Missing invoices were reconstructed. The discovery was aided by code, scripts that gathered data and surfaced anomalies far faster than manual checking ever could. But the creation of missing invoices was still done by hand. It was supposed to be a one off task, and initially I assumed the volume would be small enough to finish manually. By the time I realised the scale, I was already halfway through, too far along to justify building automation for something I would never need to run again.
The Xero integration wasn’t just a connection, it became the source of truth that the platform wrapped around and made human readable.
The key design decision was ruthless simplicity:
A resident opens the app, sees their balance, pays, and immediately gets a receipt.
No waiting. No calling the office. No second guessing. The receipt became the trust mechanism.
The Build
Core decisions:
- Xero as accounting backbone, rather than rebuilding accounting logic, the app surfaced Xero data in a resident friendly way
- Payment integration with instant receipt, the receipt wasn’t a nice to have, it was the entire product insight
- Vehicle automation, auto block for outstanding accounts, automated reminders
- Minimal friction design, residents shouldn’t need training to use it
The hardest part wasn’t the code. It was the data reconstruction, identifying every missing invoice, every anomaly, ensuring the foundation was clean before building on top of it. Bad data in means bad trust out.
Where My Judgment Showed Up
AI tools were not part of this build, this was 2021. Every architectural and product decision was manual.
The critical judgment calls were:
- Choosing not to rebuild accounting logic, Xero already did this well. The value was in the layer on top, not underneath
- Prioritising the receipt feature above everything else, this was the insight that changed resident behaviour, not the dashboard or the features
- Fixing data before launching, launching on bad data would have destroyed trust faster than no app at all
The Outcome
| Metric | Before | After |
|---|---|---|
| Collection rate | ~20% | ~90% |
| Resident confidence | Low | High |
| Manual follow up effort | High | Automated |
| ”Have I paid?” queries | Frequent | Near zero |
Households that had never paid became regular paymasters, not because of enforcement alone, but because the system made paying feel safe and confirmed.
The automation layer (auto block, reminders) reduced the human effort of chasing outstanding payments while keeping the pressure consistent and fair.
What I Learned
The real product was trust, not software.
Every feature decision that stuck was one that reduced ambiguity for the resident. The payment receipt wasn’t a technical feature, it was a psychological one. It answered the question residents were actually afraid to ask, “Did my money actually go somewhere safe?”
The collection rate improvement wasn’t driven by adding more features. It was driven by removing one specific doubt.
That’s the lesson I carry into every project now, find the doubt, remove it, and the behaviour change follows.
The Reality Behind the Build
EV3 wasn’t built with AI assistance, generous budgets, or a clear roadmap. It was built by an engineer who was also a treasurer, someone who felt the problem before writing the first line of code.
The platform cost nothing to run in its early months. The financial compensation never matched the real value delivered.
But collection rates went from 20% to 90%. Residents who never paid became paymasters. A neighbourhood that didn’t trust its own accounting now runs on visibility and automation.
That’s what happens when an engineer is given a role and chooses to solve the problem.
The platform is live at ev3.myjiran.com, having moved from its original home at ev3.code3.io.