We Didn’t Win — But We Built Something Worth Keeping

NyumbaConnect: The hackathon story

There is a weird silence after a hackathon ends. The laptop finally cools down, the demo adrenaline drains out of you, and you start replaying every decision you made under pressure. The judges have spoken. The scores are in. Your project — NyumbaConnect — did not finish in the top three.

That stings. I'll keep it a buck.

But here's what nobody tells you about hackathons: the podium is not the point. The real win is leaving with a sharper problem, a working product, and enough conviction to keep building. We left with all three.

The Problem Nobody Wants to Talk About

In Dar es Salaam — and across much of East Africa — rental management is still painfully analog. Not "analog" in some nostalgic, hipster way. I mean landlords chasing rent through WhatsApp messages, tenants paying via mobile money without consistent receipts, maintenance requests lost in phone call logs, and lease expiry dates living exclusively in someone's memory.

The worst part? Most property software assumes everyone has a smartphone and reliable internet. That assumption breaks when your tenant is a university student with a basic feature phone and pay-as-you-go data.

We built NyumbaConnect to face that reality head-on.

What We Built

NyumbaConnect is a landlord-first PropTech platform with two entrances:

1. A web dashboard for landlords and property managers to handle properties, tenants, payments, maintenance, leases, and messages.

2. A USSD interface for tenants to check rent balances, report maintenance issues, and initiate payments — from any phone, no internet required.

The positioning line we settled on: Everything tied to a unit, a tenant, and a due date.

Because that's what landlords actually need to know. Not abstract metrics. Not fancy charts. Just: who has paid, who hasn't, and which property needs attention.

The Technical Build

Stack:

• Framework: Next.js with React and TypeScript

• Styling: Tailwind CSS with shadcn/ui components, plus Hero UI for visual polish

• Backend: Supabase (Postgres, Auth, Storage)

• Telco Integrations: Africa's Talking — SMS, USSD, Payments, and Voice APIs

• Deployment: Vercel

• Version Control: GitHub

The Architecture

The web dashboard connects landlords to their properties. Each property has units, each unit has tenants, each tenant has a lease with due dates. Payments flow in, maintenance tickets get created, and the dashboard reflects the current state.

The USSD side is where things get interesting. When a tenant dials a USSD code, Africa's Talking routes the session to our API. We match the phone number to the tenant record, present a menu, and process the request. Check balance? Here's your outstanding rent. Report maintenance? A ticket gets created and the landlord gets notified via SMS.

SMS is the notification layer — rent reminders, payment receipts, maintenance updates. All automated.

Africa's Talking Sandbox

For the hackathon demo, we used Africa's Talking Sandbox to show the USSD and SMS functionality without requiring production credentials.

The tenant-facing USSD menu includes:

• Check Rent Balance

• Report Maintenance

• View Lease Information

• Contact Landlord

The sandbox let us simulate full USSD sessions — from the initial CON response to the final END — without a live USSD code. SMS notifications covered rent receipts, maintenance confirmations, overdue reminders, and landlord alerts for new requests. Production delivery needs approved sender IDs, but the full flow was demonstrable.

The mobile money payment flow is built but marked sandbox-blocked. The Payments API requires additional verification with Africa's Talking that we couldn't get through during the hackathon window.

AI-Agent Workflow

One thing I'm genuinely proud of: we structured the build using PRD-driven AI agent workflows. Each feature had a document that enforced a four-step sequence — build, test locally, verify manually, commit only after success.

The rules were strict: no pushing without human approval, no committing secrets, no inventing API keys. We created .env.example placeholders when credentials were needed and clearly marked incomplete integrations as mocked, pending credentials, or sandbox-blocked.

This mattered because under hackathon pressure, it's easy to let AI generate demo code that looks real but falls apart under scrutiny. We wanted production-adjacent code from day one.

The Login Page We Almost Missed

Early in the build, the login page had a line that said something like "Sessions are protected with Supabase Auth when credentials are configured." Implementation-facing text. It has no business being on a landlord's login screen.

We caught it, removed it, and rewrote the copy to face the customer:

• Sign in: "Welcome back. Sign in to manage your properties, tenants, payments, and maintenance workflows."

• Create account: "Create your landlord account. Start managing rent, tenants, properties, and maintenance from one connected workspace."

Small change. Big difference in trust perception.

The login page also got a clean dark SaaS style with a subtle background animation — enough to feel professional, not enough to distract. We wanted landlords to feel like they were logging into something real.

The Dashboard That Almost Wasn't

The sidebar almost broke us.

The goal was simple: a collapsible sidebar on desktop that expands on hover, collapses when the mouse leaves, and stays as a drawer on mobile. No clicks required on desktop. Real routes. Active route highlighting. Logout that actually works.

Sounds trivial. Under hackathon time pressure, every interaction becomes a negotiation between scope and quality.

We got there. The navigation covers: Dashboard, Properties, Tenants, Payments, Maintenance, Leases, Messages, USSD, Chat Logs, and Settings. Dark mode and light mode both work. The design system supports English and Swahili language switching.

What Went Wrong

Scope creep. We wanted to show a complete flow: landlord adds tenant → tenant uses USSD → system sends SMS → dashboard updates. In a hackathon, that full loop is ambitious. We ended up with solid components but some integrations marked as mocked or pending credentials.

Africa's Talking credentials. Some APIs — particularly the Payments API — require credentials we couldn't obtain during the hackathon. We built the integration layer correctly but had to mark it sandbox-blocked. SMS and USSD flows work in mock mode with database logging, but real mobile money payments need production credentials.

Testing time. We didn't run the demo loop enough times before presentations. A few UI edge cases surfaced during the demo that we'd caught in development but hadn't fully regression-tested. Classic hackathon tax.

AI output cleanup. AI agents are fast — sometimes too fast. We spent real time turning generated code into maintainable product code: refactoring boilerplate, removing placeholder comments, making sure types were safe. This is where optimism gets audited.

What We Learned

Start with the real customer. The customer is the landlord. The tenant is the user. Those are different personas with different needs. The landlord pays for the platform, so the dashboard has to answer their operational questions — who's paid, who hasn't, what's broken, what's expiring.

Build for the phones people actually use. USSD is not a fallback feature. In this market, it's infrastructure. A tenant with a basic Nokia should be able to check their rent balance and report a leaking roof. That's not an edge case — it's the market.

A beautiful dashboard is decoration if it doesn't help anyone decide anything. The value is in connecting tenant actions to landlord visibility, not in features for their own sake.

Demo loops beat feature lists. For the judges, we should have shown one complete user journey rather than walking through everything the dashboard can do. Next time: show, don't tell.

AI agents need guardrails. Without PRDs, they hallucinate, overbuild, and ship demo code that looks production-ready but isn't. The PRD workflow saved us from ourselves more than once.

Polish after clarity, not before. A beautiful login page can't save unclear product logic. Get the core flows right first, then make them look good.

The Team Behind NyumbaConnect

NyumbaConnect was not a solo build. It was built through team effort by Junior Jovin, Gadi Josephat, Ehudi Joha, and Marco Sussack.

• Junior Jovin and Gadi Josephat — Front-end development. Junior worked alongside me on the web dashboard, login experience, sidebar/navigation behavior, responsive layouts, theme support, language switching, and the landlord-facing UX polish.

• Ehudi Joha and Marco Sussack — Backend and logic. Ehudi and Marco handled the database logic, system flows, API behavior, USSD/SMS workflows, and the backend logic tying tenant actions to landlord visibility.

Good hackathon teams win by dividing pressure correctly. Junior and I pushed the interface; Ehudi and Marco kept the engine room from catching fire. That division made NyumbaConnect possible in the time we had.

Where It Is Now

NyumbaConnect is deployed and live: nyumba-connect-snowy.vercel.app/login

You can sign up, create properties, add tenants, and explore the dashboard. The web flow works. The USSD interface is built but needs Africa's Talking USSD service code configuration to go live. SMS works in mock mode. Payments are mocked pending production credentials.

Closing

We didn't win the podium. That would have been nice.

But the project did what a good hackathon project should do — it forced the idea to face reality. We know the landlord is the customer. We know USSD and SMS are not side quests; they're the tenant on-ramp. We know the dashboard has to answer real operational questions. And we know this problem is still worth solving.

We came out of the weekend with a working product, a live deployment, and a clearer picture of what it actually takes to build software for the world people live in.

Not a bad return for a weekend.

Built by Team NyumbaConnect — Junior Jovin, Gadi Josephat, Ehudi Joha, and Marco Sussack.