Serious software, properly built.
From greenfield applications to legacy rescues – a Code Bunny will get your software into a shape you can be proud of.
Built to be maintained
Everything we ship is written for the developer who inherits it – clear architecture, boring technology, no clever traps. Five years from now it will still be a codebase you can hire for.
Tested as standard
Features ship with their test suite or they do not ship. That is what lets us upgrade, refactor, and deploy without holding our breath – and why our clients can too.
One team, no handoffs
The people who scope your project are the people who build and support it. No account managers, no offshore relay – you talk directly to the engineers.
Application Development
A Code Bunny will take your idea from spec to production – whether that is a SaaS product, an internal tool, or a customer-facing web application. We do not assemble off-the-shelf parts and call it custom development.
- SaaS platforms. Multi-tenant products with billing, roles, and admin – we run competition-management SaaS in production today.
- Internal tools. The bespoke booking, admin, or workflow system your spreadsheet grew out of.
- API-first builds. REST or GraphQL from day one, so a mobile app or partner integration never means a rewrite.
- Proper domain modelling. State machines, constraints, and business rules encoded where they belong – in the model, not in tribal knowledge.
- Tested as standard. Every feature ships with its test suite, which is why our deploys are boring.
- Your infrastructure. Docker and Kamal deploys to servers you own, documented for whoever comes next.
A production application your business can rely on – and a codebase the next developer will thank you for.
See it in production: BK9 HoopersLegacy Application Rescue
Inherited a codebase that nobody wants to touch? A Code Bunny will audit what you have, identify the risk, and get it back into a state you can ship from confidently. We have upgraded Rails apps from version 4 through to current, added test coverage to untested codebases, and resolved CVEs that had been sitting open for years.
- Read-only audit first. Security, dependency health, and coverage gaps in a written report – before any work is agreed.
- Rails and Ruby upgrades. One minor version at a time, from as far back as Rails 4, while the app keeps shipping.
- Coverage without a rewrite. Tests built progressively around the money paths, so refactoring stops being frightening.
- CVE and dependency triage. Years-old advisories resolved – and kept resolved.
- Performance work. Profiling, N+1 elimination, and the slow queries nobody had time to find.
- The missing manual. We document the parts no one ever wrote down.
A codebase you can ship from weekly, instead of one you are afraid to deploy.
See a rescue in the wild: The Gentleman's Groom RoomiOS & Swift Development
Native iOS applications built properly – not a web view in a wrapper. A Code Bunny will build to Apple's platform conventions, using Swift and SwiftUI, and ship something that feels like it belongs on the device.
- Swift and SwiftUI. Native for iPhone and iPad – platform conventions respected, no web view in a wrapper.
- Live-data apps. Real-time updates over WebSockets – our competition app follows scoring as it happens.
- Sign-in done properly. OAuth2 with PKCE against your existing accounts, tokens kept in the Keychain.
- The full App Store run. Submission, review notes, and rejection wrangling handled for you.
- Push, purchases, sync. Notifications, in-app purchases, and background sync – with XCTest coverage throughout.
An app that feels native because it is – and passes App Store review without drama.
See it live: the BK9 Hoopers iOS appAPI Design & Integration
APIs built to be consumed – clear contracts, versioned endpoints, proper authentication, and documentation that does not go stale. We also connect your systems to third-party platforms: payment processors, logistics, CRMs, and everything in between.
- Contracts first. Versioned REST or GraphQL endpoints with OpenAPI documentation generated from the code – so it never goes stale.
- Payments that reconcile. Stripe and GoCardless integrations with webhook retries and idempotency. No silently lost orders.
- Authentication patterns. OAuth 2.0 with PKCE, API keys, JWT – we run our own identity providers in production.
- Third-party glue. CRMs, logistics, accounting – connected with the failure modes handled, not hoped away.
- Webhooks done right. Retry logic, delivery guarantees, and an audit trail for every event.
Integrations that fail loudly, retry safely, and never silently lose an order.
See it in production: Canine Sports ClubSoftware Licensing APIs
Licensing backends for software and games – the service that decides who can run your product, on how many machines, and for how long. Whether that means always-online entitlement checks, account-based sign-in, or classic licence keys, a Code Bunny will build the licensing server and the activation flows around it.
- Key lifecycle. Generation, activation, revocation, and audit – with an admin dashboard to run it all.
- Online and offline. Always-online entitlement checks, account-based sign-in, or signed tamper-evident offline keys.
- Commercial models. Seats, trials, and subscriptions tied straight into Stripe billing.
- Client integration. Guidance for wiring desktop apps and game clients against the licensing server.
- Built to stay up. Offline-tolerant clients and health-checked redundancy, so a server blip never locks your users out.
- Revenue protection. Shared-licence abuse surfaced and shut off, without punishing honest customers.
You decide exactly who runs your software – and revenue stops leaking through shared licences.
Software licensing, in depthE-commerce Development
Custom e-commerce built around how your business actually works – not forced into a Shopify theme. From inventory management to custom checkout flows, Code Bunnies build e-commerce that handles edge cases your platform cannot.
- Bespoke storefronts. Rails, Spree Commerce, or Astro – built around your catalogue and margins, not a theme.
- Two payment rails. Stripe and PayPal side by side, with both sets of failure modes handled – we run this in production today.
- Operations built in. Inventory, fulfilment workflows, stock control, and the admin your staff actually use.
- B2B and edge cases. Pricing tiers, discount engines, and the custom rules platforms refuse to model.
- Platform escapes. Migration off WooCommerce or Shopify when the template stops fitting the business.
A shop built around how your business works – not your business bent around a template.
See it selling: The Gentleman's Groom RoomOngoing Partnership
Some clients need a Code Bunny available monthly – a team that knows their codebase and can act quickly. Our retainer arrangements give you ongoing development capacity without the overhead of a full-time hire.
- A named developer. Agreed monthly hours with someone who already knows your codebase – not a rotating cast.
- Everything counts. Feature work, bug fixes, performance, code review, and architecture guidance.
- Proactive watch. Dependency and security advisories monitored and patched before they bite.
- Priority response. Production issues jump the queue.
- No use-it-or-lose-it games. Honest accounting of hours, agreed in advance.
Senior capacity when you need it, without the overhead and risk of a full-time hire.
Have a codebase that needs looking at? Book an audit
From first call to production.
Listen & audit
Every engagement starts with understanding what you have and what you need – a conversation for new builds, a read-only codebase audit for rescues. No proposal gets written before we have looked.
Scope honestly
You get a written proposal: what we will build, what it costs, and what we would cut first if budget matters. If we are not the right fit, we say so at this stage – not after the invoice.
Build in slices
Work ships in small, reviewable increments to a staging environment you can see. Tests ship with every feature, so progress is demonstrated, not claimed.
Ship & stay
We deploy to production, hand over documentation and access, and stick around. Most clients keep a Code Bunny on call through a monthly retainer – but the handover is real either way.
Asked before you have to ask.
Can you take over a codebase another team built?
Yes – that is our Legacy Application Rescue service. We start with a read-only audit of the code, dependencies, and test coverage, then give you a written report of what state it is in and what we would tackle first. You decide what happens next; there is no obligation to continue past the audit.
How long does a Rails upgrade take?
It depends on how far behind you are and how much test coverage exists – which is genuinely the first thing we check. We upgrade one minor version at a time so the app keeps shipping throughout, rather than attempting a big-bang jump. A well-tested app can move several versions in weeks; an untested one needs coverage built around the critical paths first. The audit gives you a realistic estimate before you commit to anything.
Monolith or microservices?
For almost every business we work with: a well-structured monolith. We build modular monoliths with enforced boundaries between domains – that gives you the separation microservices promise, without the operational overhead of running a distributed system. If you genuinely outgrow it one day, those module boundaries are exactly where you would split.
How do you price work?
Project work is scoped and quoted after the initial conversation or audit – a written proposal, not an hourly meter left running. Ongoing work runs as a monthly retainer with agreed hours and a named developer. We are not the cheapest option, and we would rather tell you that up front than surprise you later.
Who owns the code?
You do. Work happens in repositories you own, deploys go to infrastructure in your name, and everything is documented for whoever comes after us. There is no lock-in by design – we want clients who stay because it works, not because leaving is painful.
What happens after launch?
Software is not finished at launch. Most clients move onto a retainer: monitoring, dependency and security updates, and a developer who already knows the codebase when the next feature is needed. If you would rather take it fully in-house, we hand over properly – documentation, access, and a walkthrough for your team.
Do we need a full specification before talking to you?
No. A clear idea of the problem is enough – turning that into a specification is part of what you are paying us for. Some of the best projects we have worked on started as one paragraph and a phone call.
Do you work with clients outside Scotland?
Yes – we work remotely with clients across the UK and beyond, with everything reviewable online as it progresses.
Not sure which fits?
Tell us where you are and where you want to be. A Code Bunny will work out the rest.
Talk to a Code Bunny