Apps, and the machinery underneath them.
We build mobile products end to end — the interface people touch, the API it runs on, and the real-time, payments and release infrastructure that decides whether it holds up on launch day.
What we build
Products where the hard part is underneath.
Anyone can draw the screens. The work that decides whether a product survives contact with real users is in the layer nobody sees.
Video and voice, billed by the minute
Matching, ringing, connection state and per-minute billing that has to reconcile to the paisa — including what happens when the network drops mid-call and both sides disagree about who hung up.
Apps where money moves between users
Balances, escrow, earnings and payouts, on ledgers that can answer a dispute six months later without anyone guessing. Withdrawals, deductions and reversals are all part of the model, not bolted on.
Products people open every day
Profiles, feeds, presence and notifications, plus the retention machinery — streaks, rewards, re-engagement — designed alongside the product rather than added once the numbers disappoint.
The panel your team actually runs it from
Moderation queues, ledger inspection, refunds, user lookup and release control. Every consumer app needs one, and it is almost always the thing that was never budgeted for.
How it ships
Six stages, in order.
Each one depends on the one before it. The colour is the scale — it runs the length of the mark, and the length of the build.
Scope
What the product is, what it costs to run per user, and what it must never do. Written down and agreed before a line of code, because unit economics discovered after launch are not fixable with a patch.
Interface
Screens built against real data and real states — loading, empty, failed, offline — not against a mockup where every avatar loads and every list has exactly four items.
Services
The API, the schema, the background jobs and the admin panel. Rates and prices live as data, so changing what something costs is a database update rather than a release.
Real-time
Calls, presence and push. Session tokens are minted server-side and expire; a credential that ships inside the app is a credential you have already lost.
Hardening
Concurrency, failure paths and money that must never double-count. Two taps on the same button, a retried webhook and a process that dies mid-transaction are all tested, not assumed away.
Release
Signing, store listing, policy review and a staged rollout you can halt — with the dashboards and alerts to know whether halting it is necessary.
Engineering
What we work in.
Chosen for products that have to run cheaply at scale and be maintained by a small team — not for novelty.
- Mobile
- Flutter, native Android (Kotlin) One codebase where it pays, native where the platform demands it — permissions, call audio, notification channels.
- Services
- Laravel, PHP 8.3, MySQL Boring, well-understood and cheap to host. Queue workers and scheduled jobs for everything that must not run inside a request.
- Real-time
- Agora RTC, server-minted tokens Live video and voice with short-lived credentials renewed mid-session, so the certificate never reaches a device.
- Messaging
- Firebase Cloud Messaging (HTTP v1) High-priority channels for calls, standard for everything else, so a ringing phone behaves like a ringing phone.
- Money
- Append-only double-entry ledgers Balances are derived, never stored. Every credit and debit keeps its reason, and wallet writes take a row lock so two spends cannot race.
- Release
- R8, split ABIs, staged rollout Shipped artefacts kept small — a bloated download is a conversion problem before it is an engineering one.
We would rather spend a week on the failure path than a month on support tickets caused by skipping it.