Other
USSDly Team
USSD is the quiet workhorse of the continent. No app store, no data plan, no smartphone required. Just a code you dial and a menu that works on the cheapest Nokia. Banks, telcos, and governments lean on it every day.
Building for it, though, is stuck in the past. You negotiate access with an aggregator, write a stateful backend that survives a session timing out mid-menu, wire up mobile money, and pray you never have to move to a different provider. Weeks of plumbing before a single user dials in.
USSDly collapses that. You draw your menus on a canvas, define your data in a few clicks, hit publish, and your service is live on a real short code. We handle the sessions, the provider quirks, the payments, and the parts nobody enjoys writing twice.
We call it the USSD Infrastructure Cloud: USSD treated as real business infrastructure, not a one-off script.
What it does:
A visual flow builder. Drag menu, input, condition, API, database, and payment nodes onto a canvas and connect them. There's also an operation node for arithmetic on session variables, which is what makes things like a savings calculator or a running balance possible without code. Every flow is a project you can version, roll back, and move through a draft → publish pipeline across separate environments.
A database that comes with the app. Each project gets a managed Postgres database. Define your tables in the dashboard, and your flows can read and write them directly: a farmer registry, a loan ledger, a list of clinics. Every table also gets a scoped REST API automatically, so you can talk to the same data from outside without writing a backend.
Build once, deploy to any provider. A flow you build runs on Moolre, Hubtel, Arkesel, Africa's Talking, or Nalo without a rewrite. Under the hood each aggregator speaks its own dialect; USSDly normalizes them behind one adapter layer, so switching providers is a setting, not a rebuild.
Payments that actually settle. USSDly Payments is a Moolre-backed gateway for collecting and paying out mobile money across MTN, Telecel, and AT. It handles the OTP prompts, identity verification through Didit for KYC, a double-entry ledger, per-merchant wallets and withdrawals. Money flows are reconciled idempotently, so a dropped webhook or a redial mid-payment never double-charges or loses a transaction.
Bulk SMS and campaigns. An org-level SMS system with a credit wallet, sender IDs, scheduling, and delivery tracking, so the USSD app and its follow-up messages live in one place.
Analytics you can act on. Replay a user's journey step by step to see exactly where they dropped off. Watch conversion funnels, latency, and how each provider is performing, in real time.
An AI copilot. USSDly Copilot is a conversational assistant that builds your flows and database tables from a plain description of what you want, and points out where your menus are likely losing people. It's the difference between staring at a blank canvas and having a working draft to edit.
Templates to start from. A library of ready-made flows (payments, data bundles, SMS, savings) that provision their own data tables when you install them, so you can go from template to live service in minutes.
Who it's for?
The same platform covers very different builders:
Fintech. Mobile money, banking, lending, and savings apps, including susu-style group savings.
Government and public services. Citizen registrations, service lookups, public information lines.
Agriculture. Farmer registration and market-price information, reachable from a field with no signal bars to spare.
Health. Appointment booking, patient registration, and outreach campaigns.
The common thread: reaching people on the phone they already own, in places where a data connection is a luxury.
Inspiration:
We kept running into the same gap. Someone has a genuinely useful idea, like a savings group that collects contributions over USSD or a clinic that lets patients book by dialing a code, and the idea dies in the integration paperwork. The hard part was never the concept. It was the aggregator contracts, the session state, the payment reconciliation, the fact that USSD tooling assumes you're a bank with an engineering team.
Meanwhile the reach is enormous. Feature phones and pay-as-you-go lines are still how most of the continent gets online, and USSD is the one channel that meets them there. We wanted to make building for that channel feel like building a website: pick your pieces, publish, watch it work.
How we built it
A few decisions did the heavy lifting:
Session state in Redis. USSD is stateful but each request is a fresh HTTP call from the aggregator, often with an aggressive timeout. Keeping session state in Redis lets a flow pause on a menu and pick up exactly where it left off, fast enough that the network doesn't hang up on us.
One canonical model, many adapters. Every provider gets an adapter that translates its request and response shape into a single internal format. The interpreter that walks a flow never knows or cares which telco it's talking to.
Money treated like money. Everything financial is in integer minor units (pesewas, not floating-point cedis), and every payment transition is a guarded, idempotent state change. Webhooks get replayed, users redial, networks drop; the ledger still balances.
A background safety net. Payment confirmation doesn't trust a single webhook. If a provider callback is missed, a reconciliation job re-checks the transaction status directly and fulfils it once, so a subscription or a credit purchase never gets stuck half-done.
AI with guardrails. The copilot speaks a structured action protocol rather than free-form edits, so it builds real flows and tables the platform can validate, not a wall of text you have to translate yourself.
The whole thing is Zod-validated at boot and ships with a one-command production bootstrap, because a platform that's a nightmare to deploy isn't infrastructure.
Challenges we ran into
USSD is unforgiving in ways a web app isn't. A session can vanish between two keypresses. Aggregators disagree on nearly everything: how they signal the end of a session, how they encode a phone number, whether a timeout looks like a hang-up or an error. Getting five of them to behave identically behind one interface took real care.
Payments were the other hard mile. Mobile-money flows have OTP steps, out-of-band push prompts, and webhooks that arrive late or not at all. Making that safe meant designing every money path to be replay-safe from the start: no double charges, no lost transactions, and correct behavior when someone redials into a payment that's still pending, plus reconciliation that assumes the happy path will sometimes fail.
Accomplishments we're proud of
A single flow that genuinely runs on five different providers with no rewrite.
A payment layer that stays correct under dropped webhooks and redials, backed by a real ledger.
An AI copilot that turns a sentence into a working USSD flow with its own database behind it.
End-to-end: someone with no backend experience can define data, build a flow, deploy it to a live code, and watch real sessions come through, all in one sitting.
What's next
A typed TypeScript SDK so developers can drive their project's data and flows from their own code.
Deeper analytics: cohort retention and smarter drop-off detection surfaced automatically by the copilot.
More providers and more countries, expanding past Ghana's networks to the wider region.
A richer template marketplace so common services (savings, registrations, bill payments) are a few clicks from live.
