Prepared for Michael Smorenburg  ·  What It Takes + Running Costs
CrisisNexus  ·  Pilot Readiness

What it takes to go live

Building the software is the fast part, and it is mostly the part we do. Turning it into a running emergency service takes more than a build, and it is honest to say so up front.

This is the full picture: the third-party services with monthly subscriptions, the accounts only a person can open, the partner deals with the towns and responders, the legal and privacy work, and the management it takes from your side while Lumanaire builds. With indicative running costs, a lean pilot versus a sovereign production system.

Built by Lumanaire Prepared for Michael Smorenburg Scope Third-party costs + readiness
0
Things needed beyond the code
0
Third-party accounts to open
$0
Lean pilot, per month (est.)
0
Partner deals to land
The honest version

A build is not the same as a service

Prompting an AI builds a working app and a convincing demo quickly. It does not, on its own, create a running emergency service. The difference is everything around the code, and for something people's lives touch, that is exactly where the time and money belong.

The code is weeks of work and the cheap part. The accounts, subscriptions, partner deals, compliance and vigorous testing are the long pole and the real cost.

The division of labour

Who does what

Lumanaire and the AI carry the build. Some things, by their nature, only a person can do, and some things are deals that move slower than any code.

Lumanaire builds

Fast, AI-assisted
  • The orchestration core and incident engine
  • The operator console and human-in-the-loop UI
  • Every channel and responder adapter
  • The acknowledgment loop and escalation logic
  • Speech-to-text wiring, once accounts exist
  • Dual logging, audit, the canonical schema, tests
  • Deployments and hosting setup

You manage

Human, ongoing
  • All accounts, billing, budgets and KYC
  • The product decisions we surface
  • Recruiting and running the testing
  • The client and responder relationships
  • Approvals for anything external
  • Real-world verification: real calls, real devices
  • Watching the meters so usage does not surprise you

Needs a partner deal

Slow, relationship-led
  • Each town agreeing to run in parallel
  • Each responder agreeing to receive and acknowledge
  • Carrier shortcode and zero-rating (later)
  • WhatsApp business verification with Meta
  • Privacy (POPIA) and liability sign-off
  • Responder data-sharing terms
  • Sovereign in-country hosting, if required
The running costs

What it costs to keep it live

These are third-party running costs only. They exclude Lumanaire's build fee, which is quoted separately. Two scope levels drive the bill: a lean cloud pilot to prove the loop, and a sovereign production system at full scale.

Lean cloud pilot

Prove the loop

$300 to $500 / mo
plus roughly $150 one-off
Cloud speech-to-text, no shortcode, no GPU, no native app. Enough to run in parallel and earn trust in two towns.
Sovereign production

Full scale

$3,000 to $4,500 / mo
plus roughly $6,000 to $18,000 one-off
In-country hosting, self-hosted and fine-tuned speech-to-text, dedicated shortcode, redundancy, and legal. The SPEC vision, not the pilot.
Line item Tier Lean pilot Sovereign
Fixed monthly subscriptions
Hosting VercelCore$20$30
Database Supabase / SA PostgresCore$25$300
Auth + MFA Clerk / Supabase AuthCore$25$80
Maps + tiles MapTilerCore$25$50
Monitoring + uptime Sentry + uptime checkCore$26$120
Sovereign compute SA cloud region, redundantSovereign$500
Self-hosted STT (GPU) Whisper / MMS, fine-tunedSovereign$800
Usage, scales with call volume (monthly estimate)
AI engine Anthropic (Claude)Core$50$350
Speech-to-text Google Chirp 3 / ElevenLabsCore$40$150
Voice telephony Twilio / Africa's TalkingCore$40$300
SMS SMS gatewayCore$20$200
WhatsApp Meta BSP, 360dialog / ClickatellCore$40$300
Dedicated shortcode Carrier, monthlySovereign$500
Monthly total$311$3,680
One-off setup (not monthly)
Domain Have lumanaire.co.zaCore$0$0
Meta verification WhatsApp prerequisiteCore$0$0
Integration setup Provider wiring + configCore$150$150
Shortcode setup Carrier onboardingSovereign~$3,500
App store accounts Apple + Google, responder appFast-follow$125
STT fine-tuning GPU compute, local audioSovereign~$2,000
Legal + POPIA External law firmSovereign~$6,000
One-off total~$150~$11,775

Indicative estimates in USD to validate with each provider, not quotes. Local providers (Africa's Talking, Clickatell) bill in ZAR. Usage lines assume low pilot call volume and rise with real traffic. Sovereign one-off ranges: shortcode setup $2,000 to $5,000, fine-tuning $1,000 to $3,000, legal and POPIA $3,000 to $10,000 (external counsel). The full editable line-by-line model is in the accompanying spreadsheet.

The human-only work

What the AI cannot do for you

Lumanaire wires every one of these into the app the moment it exists. Lumanaire cannot bring them into existence. Each needs a person, and often a card, a registered business, and identity checks.

Open the accounts

  • Ten-plus third-party services, each with billing
  • A verified Meta Business account for WhatsApp
  • A registered business identity for carriers and Meta
  • A budget owner watching every meter

Land the deals

  • The towns, to run in parallel
  • Each responder, to receive and acknowledge
  • Carriers, for the shortcode and zero-rating
  • Meta, for WhatsApp verification

Cover the legal

  • POPIA: citizen data and voice recordings
  • Liability and the "orchestration, not responder" posture
  • Contracts with the town and responders
  • Data residency, if sovereignty is required
Your side, while we build

The management it takes

Even with the AI doing the building, the human load is real and continuous. This is the part that is easiest to underestimate.

01

Own the accounts and money

Every sign-up, every card, every budget, watching the meters so a usage bill never surprises anyone.

02

Make the decisions

Which providers, which languages go live first, which towns, how long the acknowledgment timeout is, what counts as ready. The build constantly produces these forks.

03

Coordinate the testing

The heaviest item. Recruiting testers, running drills, sitting with town operators to compare what the system would do against what they did.

04

Manage the relationships

The towns, the responders, and the people who own them. Lumanaire builds; you are the face of it.

05

Handle compliance

POPIA, contracts, liability. Human and slow, and required before a single real caller is allowed near it.

06

Verify in the real world

Actual phone calls from actual phones, by actual responders. The "test it for real before trusting it" rule, applied to a phone system.

What blocks what

The honest sequence

The software will be ready before the deals and the compliance are. Plan for the deals and the testing to be the critical path, not the code, and start the slow things early.

Now
Mike finishes the town baseline. Jarryd opens the core accounts (AI, speech-to-text, telephony, hosting, database, auth). Lumanaire builds the loop against them.
Early
Start the WhatsApp and Meta verification and the responder conversations now, because they take longer than the build.
Before live
POPIA posture, the parallel-run testing, the acknowledgment-loop hardening, and monitoring. No real caller until these pass.
Fast-follow
Shortcode and zero-rating with carriers (months of lead), the native responder app, and self-hosted sovereign speech-to-text.
The bottom line

Where the time and money go

Lumanaire can build CrisisNexus, and the AI makes that genuinely fast. But the app is not the same as a running emergency service. The service needs paid accounts, partner agreements, privacy compliance, and ongoing management and testing from your side. The build is the fast part. The accounts, deals, compliance and testing are where the time and money go, and for something people's lives touch, that is exactly where they should go.