REST and GraphQL APIs
Versioned, documented with OpenAPI and covered by automated tests your team can run.
App back-end development: APIs, admin panels & hosting
App developers: the back end your app deserves. Ship the app, not the 2am fixes.
The front end looks a million bucks. Behind it sits a back end built in a hurry, a client who edits the database by hand and hosting nobody wants to own. Push notifications go missing and the first marketing email brings it to its knees. We build the APIs, admin panels, integrations and hosting behind mobile and web apps. Then we look after them so your team can get back to building the thing users actually see.
Looking for an app back-end development partner who'll still be around after launch?
Most app studios are brilliant at the bit people tap on. The back end gets squeezed into the last few sprints: an API that grew one endpoint at a time, auth copied from an old project and a Firebase setup that's fine until the bill lands. Then the client asks for an admin panel, a Stripe subscription, a CSV export and a push campaign. Every request lands on your best mobile dev, who'd rather be shipping features.
Wollopit builds the back end as a proper product. We agree the API contract with your front-end team first, document it and test it, then build the admin panel your client can actually use. Payments, notifications, maps, SMS and third-party services get wired in properly. We host it on our own managed servers, monitor it and keep it patched, so when something wobbles at 2am it's our phone that rings. You keep the client relationship and the app. We keep the engine running.
01The problems
What we hear from app developers
Does your app development business have these problems? Here's how we'd fix them.
Most app teams we talk to don't have a back-end problem until launch week. Then they have all of them at once.
- The problemThe back end is held together with tapeAn API that grew one endpoint at a time, no tests and one dev who knows where the bodies are buried.How we fix itA clean, versioned API with automated tests and docs, so anyone on your team can pick it up.
- The problemThe client edits the database by handEvery content change, refund or banned user is a ticket to a developer who opens the database and hopes.How we fix itAn admin panel built for the client: content, users, orders and settings with proper roles and an audit log.
- The problemThe front end waits on the back endMobile devs sit on mocked data for weeks while endpoints keep changing shape under them.How we fix itWe agree the API contract up front, ship a mock server on day one and keep it in step with the real thing.
- The problemPush notifications go missingSome users get three, some get none and nobody can tell which tokens are stale.How we fix itA notification service across APNs and Firebase Cloud Messaging with token clean-up, scheduling, segments and delivery logs.
- The problemPayments are a can of wormsStripe webhooks half handled, in-app subscriptions out of sync and refunds done in the dashboard by hand.How we fix itStripe and in-app purchase handling done properly, with receipts validated, webhooks retried and subscription status in one place.
- The problemHosting nobody ownsThe server lives on someone's personal AWS account and the SSL certificate expires during the client's big launch.How we fix itManaged hosting on our servers with backups, monitoring, uptime alerts and certificates that renew themselves.
- The problemIt falls over under loadThe client's TV spot goes to air and the API slows to a crawl right as the downloads spike.How we fix itLoad testing before launch, caching, queued background jobs and database tuning so spikes are boring.
- The problemLogin and security are an afterthoughtHome-made auth, passwords in logs and no idea who has access to production.How we fix itSolid auth with social sign-in, magic links and two-factor, plus role-based access and the Privacy Act basics covered.
- The problemIntegrations break quietlyA third-party API changes, a sync job fails and nobody notices until a customer complains.How we fix itIntegrations built with retries, alerts and logs, so failures surface in Slack before your client spots them.
- The problemNobody can see what's going onA crash in the app could be the front end, the API or the server and everyone points at each other.How we fix itError tracking, request logs and a health dashboard that shows where a problem actually lives.
- The problemSupport after handover is a messThe project ends, the client keeps ringing and fixes get squeezed between paying jobs.How we fix itAn ongoing care plan where we host, patch and maintain the back end, with changes scoped and quoted up front.
02What we build
Solutions
What we build for app developers. Usually all talking to each other.
Pick the one that's hurting most or join the whole lot up. Everything is built around how your team works, not the other way round.
Admin panels
Content, users, orders, moderation and settings with roles your client can manage themselves.
Auth and user accounts
Email, social sign-in, magic links, two-factor and account deletion done to App Store rules.
Push and email notifications
APNs and Firebase Cloud Messaging, transactional email and SMS with templates and delivery logs.
Payments and subscriptions
Stripe, Apple and Google in-app purchases, RevenueCat and webhooks handled properly.
Third-party integrations
Maps, SMS, CRMs, accounting, booking platforms and whatever your client's industry runs on.
File and media handling
Uploads, image resizing, video processing and secure downloads from proper storage.
Background jobs and queues
Imports, exports, scheduled tasks and heavy lifting moved off the request so the app stays quick.
Real-time features
Chat, live updates and presence over websockets without melting the server.
Managed hosting
Hosted on our servers with backups, staging and production, uptime monitoring and alerts.
Performance and load testing
Find the slow queries before launch day does, then fix them with caching and tuning.
Back-end rescues
Take over an inherited or half-finished back end, stabilise it, document it and make it safe to change.
Analytics and reporting
Usage dashboards and client reports from your own data, not just what the app stores show.
03The systems
The big ones
Everything behind the app, built properly.
These are the back-end pieces app developers ask us about most. We can build one for a single project or become the back-end team behind all your apps.
APIs
An API your front-end team actually trusts.
We agree the contract with your mobile and web devs before writing code, then ship a mock server so nobody waits. The real API is versioned, documented and tested, so a new release never breaks the version still sitting on someone's old phone.
- API contract agreed up front
- Mock server from day one
- OpenAPI docs that stay current
- Versioning for old app releases
- Automated test suite
- Rate limiting and input validation
- Pagination, filtering and search
- Staging and production environments
- Webhooks for client systems
Admin panels
Your client runs their app. Your devs stop doing data entry.
A web admin panel shaped around how your client works, not a raw database viewer. Content, users, orders and refunds are handled by the people who own them, with an audit log so everyone knows who changed what.
- Content and CMS screens
- User search, bans and support notes
- Orders, refunds and payouts
- Roles and permissions per staff member
- Audit log of every change
- CSV imports and exports
- Moderation queues
- Feature flags and app settings
- Branded in your client's style
Notifications & messaging
Push, email and SMS that actually arrive.
One notification service the whole app talks to. It handles device tokens, quiet hours, segments and templates across push, email and SMS, then logs every send so you can prove it went.
- APNs and Firebase Cloud Messaging
- Stale token clean-up
- Segments and scheduled campaigns
- Transactional email via Postmark or SendGrid
- SMS via Twilio
- Quiet hours and user preferences
- Deep links into the right screen
- Delivery and open logs
Payments & integrations
Money and third parties, wired in properly.
Stripe, in-app purchases and the client's other systems connected with retries, alerts and logs. Subscription status lives in one place so the app, the admin panel and the accounts all agree.
- Stripe payments and Connect payouts
- Apple and Google in-app purchases
- RevenueCat subscription sync
- Webhooks retried and logged
- Xero invoices and payments
- CRM sync with HubSpot
- Maps and location services
- Failure alerts to Slack
Hosting & care
Hosting someone actually owns. Us.
We host the back end on our own managed servers with staging, backups and monitoring. We patch it and watch it, then improve it when the client wants more, so a launch-day spike is our problem and not your weekend.
- Managed servers in Australia
- Staging and production
- Daily backups with restore tests
- Uptime and error monitoring
- SSL that renews itself
- Security patches kept current
- Load testing before launches
- Scoped changes quoted up front
04How it changes
Before and after
An app launch, wolloped.
Here's how launch week could change. Every app is different, so we map yours first.
Before
- Endpoints still changing the night before submission
- Client's promo goes live and the API slows to a crawl
- A dev edits the database to fix a user's account
- Push notifications reach half the users
- Someone finds the SSL certificate expired
- Hosting panic in the group chat
After
- API contract locked and tested weeks ago
- Load tested before launch, so the spike is boring
- The client fixes the account in the admin panel
- Notifications delivered and logged
- Certificates renewed themselves
- Monitoring alerted us first and we handled it
05Services
Everything under one roof
Software, websites and systems for app developers.
Whether you're starting fresh or upgrading what you've got, it's one team from the first sketch to the support call.
Custom software for app developers
Built around how your app development business actually runs: rEST and GraphQL APIs, admin panels and the admin in between, in one system you own.
Websites for app developers
Fast, hand-built websites that rank for the searches your customers make and turn visits into enquiries, bookings or orders.
App development business system upgrades
Running on spreadsheets, old software or a platform you've outgrown? We move your data across and upgrade in stages so the business never stops.
Apps and portals for app developers
Auth and user accounts and push and email notifications: customer and staff portals that work on any phone without an app store.
Integrations and automation
We connect Stripe, RevenueCat and Firebase so information moves on its own and nobody retypes it.
Hosting, support and care
Managed hosting, updates, backups and security for your app development business, looked after by the people who built it.
06Integrations
Connections
Plays nicely with what you already use.
We work with the stack your app already uses, plug into your team's tools and replace the bits that keep breaking.
- Stripe
- RevenueCat
- Firebase
- Supabase
- AWS
- Twilio SMS
- Postmark
- SendGrid
- Auth0
- Sentry
- GitHub
- Jira
- Slack
- Xero
- HubSpot
- Google Maps Platform
- App Store Connect
- Google Play Console
- Expo
- Zapier
07How we work
The process
Some people dip their toe in. We turn up in a rebreather.
We get properly below the surface of your app development business: the systems, the busy days and the jobs everyone hates. Then we fix the bits that matter most first.
- 01
Think
We sit down with your team and the client brief to work out what the app really needs behind it and what's already wobbling.
- 02
Archi-tech
We plan it before writing code: the API contract, data model, auth, integrations, hosting, scale and cost, agreed with your front-end devs.
- 03
Build
Real engineering in small releases with a mock server first, so your app team is never waiting and you get a win early.
- 04
Look after
We host it, monitor it and keep it patched. When something breaks you call the people who built it.
08Questions
FAQ
Things app developers ask us.
Something else on your mind? Ring 0423 011 252 and ask the people who'd build it.
Can you work with our front-end team?
Yes. We agree the API together and work alongside your mobile and web developers in your Slack and Jira, so it feels like one team.
Can you white-label the work for our clients?
Yes. Plenty of studios want the back end handled quietly. You keep the client relationship. We build, host and support it behind the scenes.
We already use Firebase or Supabase. Do we have to switch?
No. If it's doing the job we build around it and add what's missing, like an admin panel or proper integrations. If it's costing you too much or holding you back, we'll show you what moving would involve before anything changes.
Can you take over a back end someone else built?
Yes. We review it, stabilise it, add tests and docs, then move it onto managed hosting once it's safe to change.
How much does a back-end build cost?
It depends on what the app needs, so we quote up front once we understand it. No surprise invoices, no lock-in and you or your client own what we build.
How long does it take?
We work in stages. Your front-end team gets a mock API straight away and the first real endpoints follow early, instead of everything landing the week before launch.
Who looks after it once it's live?
We do. We host it on our own managed servers and keep it monitored, backed up and patched. When you need something you ring the people who built it.
Can it handle a big launch or a spike in users?
Yes. We load test before launch, add caching and background queues where they matter and watch it closely on the day.
We already have systems. Can you upgrade them instead of starting again?
Usually, yes. Most app developers we work with keep what's working and upgrade the rest in stages. We move your data across, connect the old and new while we switch and retire the old system only when the new one is proven.
Contact
Got an app development business problem? Consider it wolloped.
Tell us what's slow, broken, manual or missing. You don't need a spec, just describe what's going on.