THE PROBLEM - How serving as a financial secretary exposed a broken process - and led me to build RCMS

A few years ago, I wasn’t trying to build a startup.

I was serving as the Financial Secretary in the residential estate where I lived, and my biggest daily problem was keeping up with manual records - tracking dues (both current & outstanding), updating arrears, issuing receipts, and answering constant calls from residents asking about their payment status.

We relied on spreadsheets, WhatsApp messages, and paper receipts. Even when I tried to “improve things” with Excel, the stress didn’t go away.

When I later moved to another estate and saw the exact same problems, it became clear this wasn’t just a local inconvenience - it was a systemic issue.

That experience is what eventually led me to build RCMS (Residential Community Management System).

TL;DR

While serving as a financial secretary in a residential estate, I experienced firsthand how manual estate management - spreadsheets, WhatsApp groups, and paper records - leads to confusion, disputes, and inefficiency.

After seeing the same problems across multiple communities, I built RCMS (Residential Community Management System) to digitize resident records, payments, receipts, reporting, and visitor management in a single platform, eliminating spreadsheets and bringing transparency to estate management.

THE SOLUTION - How I Built RCMS and What It Does

Although RCMS started from a real-world problem, building it still required making deliberate technical decisions around structure, data flow, security, and scalability.

With my knowledge as a Cloud Solutions Architect(AWS), I was able to set up the overall system blueprint myself - including the architecture, core workflows, data models, and boundaries between features like payments, resident records, and access control.

However, I didn’t write every line of code manually.

I used Replit’s AI agent as a development assistant to speed up implementation. The AI helped with scaffolding features, generating boilerplate, iterating on repetitive patterns, and accelerating experimentation - while I remained in control of "what" was being built and "how" it fit into the overall system.

The way I think about it is simple:

I defined the blueprint and constraints. The AI helped execute faster within those boundaries.

Even with that acceleration, RCMS still took close to 12 months of building, testing, and iteration before it was stable enough to deploy to production. Most of that time wasn’t spent writing code, but validating community management workflows, handling edge cases, and ensuring the system behaved predictably in real-world use.

This approach allowed me to move quickly without sacrificing structure or intent. The hard parts - understanding the domain, modeling residential estate operations workflows, handling edge cases, and designing for transparency and accountability - still required human judgment shaped by lived experience.

AI didn’t replace the thinking. It amplified the execution.

And for a problem as nuanced as residential community management, that balance mattered.

RCMS is a mobile-responsive web application designed specifically for residential estates - not generic accounting software, not chat apps, not patched-together tools.

It enables residential estates to:

automate dues calculation, while accurately capturing arrears & outstanding dues

auto-generate and email digital receipts

securely store resident records and payment history

generate transparent financial reports

track visitors and vendors using digital access codes

In simple terms:

A smarter, structured, and transparent way to manage residential communities

Financial Reports Dashboard

Residents Directory

RCMS Dashboard on Mobile

Tech Stack & Architecture

RCMS was designed as a practical, production-oriented system rather than a demo project. The goal was reliability, clarity, and room to scale as real communities onboard.

At a high level, the system is structured as a modular web application with clear separation between core domains like residents, payments, communication, and security.

Current stack:

• Frontend:- React 18 + TypeScript
• Backend API:- Node.js 20 (Express) framework
• Database:- PostgreSQL (relational model for financial accuracy and auditability)
• ORM:- Drizzle ORM
• Authentication & Authorization:- Role-based access control (admin, financial secretary, treasurer & secretary)
• Email:- Transactional email for onboarding, receipts, and notifications
• Hosting:- Cloud-based deployment, designed with AWS-compatible architecture in mind

Key architectural decisions:

• Financial data is modeled conservatively to avoid ambiguity in dues, outstanding dues, arrears, and receipts
• Role boundaries are explicit to prevent privilege leaks (especially around payments, expense creation/approval and records)
• Features are modular so estates can adopt RCMS incrementally
• The system is optimized for environments with inconsistent connectivity
• Multi-tenant architecture to safely accommodate multiple communities

The emphasis throughout was not “over-engineering,” but building something that mirrors how estates actually operate - with clear records, traceability, and accountability.

---

Want to See RCMS in Action?

If you’re curious how RCMS works in practice:

• 🔗 Product page: https://www.civichubng.com/rcms-product
• ▶️ YouTube walkthrough: https://www.youtube.com/@CVICHUBLTD

Happy to answer questions or walk through real use cases.