Exact instructions. Enduring software.

We design and engineer custom software, from a focused internal tool to the platform a company runs on, and mobile games made to be played for years. Like guilloché cut on a rose engine, every line follows an exact specification.

Start a project See what we build
Guilloché, cut by a rose engine from one formula, computed live in your browser.Cut by a rose engine from
k
12
a
0.072
φ per line
±0.031
lines
220

A rose engine cuts guilloché by following exact instructions. We build software the same way.

The pattern on a watch dial or a banknote is never drawn freehand. A machine generates it from a few exact settings, which is why it repeats perfectly and is so hard to forge. We write software that way: the surface is only as good as the instructions underneath.

Custom software, built around how your business works.

Off-the-shelf tools make you adapt to them. We build each system for one company, and make it fast, secure and easy to hand over. Most of what we build is used every working day by people who never asked for new software, so it has to earn its place.

reconcile.tsOrders against ERP invoices, posted to a ledger.
export async function reconcile(day: Day) {
  const orders = await shop.orders(day);
  const invoices = await erp.invoices(day);
  const ledger = match(orders, invoices);
  // every line accounted for
  ledger.unmatched.forEach(flag);
  return ledger.post();
}

Short functions, named for what they do, and readable for whoever maintains them in ten years. Beside this listing, a diagram shows the same system: orders from a storefront and invoices from an ERP flow into the reconcile function, which posts to a ledger and sends anything unmatched to a review queue. Further down, an agent joins the system and works alongside the reconcile function.

What we build

Internal platforms
The operational core: orders, scheduling, inventory, approvals and reporting.
SaaS products
Multi-tenant products with accounts, roles, billing and an admin side.
Client portals
Where your customers sign in to see their data, documents and orders.
High-traffic systems
Services that stay fast under heavy load: partitioned and sharded data, event streams, caching and autoscaling, observable end to end.
Data-heavy tools
Dashboards, search and pipelines over large or messy datasets, answering in a second.
Integrations
ERP, CRM, accounting, payments and logistics, connected with errors handled and retried.
Web and mobile apps
Customer-facing apps on the web, iOS and Android, sharing one back end.
AI and agentic systems
Agents that read, decide and act inside your own tools.

Agentic AI, held to exact standards.

The model is probabilistic. The system around it should not be.

Most AI projects stall between an impressive prototype and something a business can rely on. We build the system that closes that gap: agents that use your tools and data to carry out multi-step work, engineered with the same rigour as everything else we ship.

  • Agents and multi-agent workflowsPlanning, tool and API calls, hand-offs between specialised agents, long-running tasks that resume where they stopped.
  • Grounded in your dataRetrieval over documents, databases and internal systems, with every answer traceable to its source.
  • Guardrails and human approvalPermissions per action, approval at the steps that matter, every decision logged.
  • Evaluated on your real casesEvaluation suites built from your own examples, run before and after every change to prompts, models or tools.
  • Model-agnosticThe right model for each task, with cost and latency budgets agreed up front.
  • Deployed on your termsYour cloud, your keys, your data kept where it belongs.

Inherited a codebase nobody wants to touch?

We start with a fixed-scope audit covering architecture, security, performance, test coverage and the real cost of the technical debt. You receive a written report and a clear recommendation: fix, extend or rebuild. If we take it on, the first milestone is always stability, before any new features.

Included in every build

  • Your code, in your accounts. Repositories, cloud, domains and store accounts are in your name from the first commit.
  • Written specification. What will be built, what won't, and how we'll know it's done, agreed before development starts.
  • Documentation and handover. Architecture notes, setup instructions and a recorded walkthrough.
  • Automated tests and CI. Every change is tested and deployed through a pipeline.
  • Performance budgets. Load and response times agreed up front and measured on every release.
  • Security by default. Access control, encryption, dependency scanning and an OWASP Top 10 review before launch.
  • Accessibility. Interfaces built to WCAG 2.2 AA.

Games are software under pressure.

Sixty frames a second on a three-year-old phone. Judged in thirty seconds, kept or deleted within thirty days. Few briefs are less forgiving, which is why we take them on. We build mobile games from concept to store and beyond: controls that feel right, visuals that read on a small screen, and the live operations that keep players coming back.

  • Concept to store launch. Prototype, production, soft launch and global release on the App Store and Google Play.
  • Performance on real devices. Smooth play on low-end and mid-range Android, tested on hardware, not only in the editor.
  • Monetisation-aware design. Ads, in-app purchases and subscriptions planned into the economy from day one.
  • Live ops. Remote config, events, A/B tests and content updates without a new store release.
  • Analytics. Retention, funnels and economy metrics wired in before soft launch, so decisions rest on numbers.
  • Engines. Unity and Godot, with native plugins where the platform needs them.

Every game we build is engineered like a product: versioned, tested, documented, and yours to own outright.

Browser games.

Instant-play games that load in seconds on mobile data: branded campaigns, playable ads and web versions of mobile titles, built with WebGL, PixiJS, Phaser or three.js.

From a focused tool to a whole platform.

The same engineering standard applies whether the work takes six weeks or two years. Only the scope changes.

  1. Focused tool

    4 to 8 weeks

    An internal dashboard, an integration between two systems, or a prototype that proves an idea.

  2. Product

    3 to 5 months

    A launch-ready SaaS product, app or mobile game, with accounts, payments, analytics and monitoring.

  3. Platform

    5 to 10 months

    Multi-role, high-traffic systems, real-time features and deep integration with the tools your company already runs on.

  4. Long-term partnership

    Ongoing

    New features, infrastructure, support and live ops, on a monthly agreement.

How a project runs.

Five stages, each ending in something you can see, test or keep. You always know where the project stands and what happens next.

  1. Discovery

    Workshops, a technical review and a risk map, ending in a written specification and a fixed quote for each phase. The specification is yours to keep, whoever builds it.

    1 to 3 weeks, fixed fee

  2. Design and architecture

    Clickable flows for software, playable prototypes for games. We test the riskiest parts first and choose the stack around your constraints, not our habits.

    1 to 4 weeks

  3. Build

    Two-week cycles, each ending in a working build on a staging link, a short demo and a written update.

    Most of the timeline

  4. Launch

    Load testing, security review, monitoring, store submissions where relevant, and a release plan with a rollback ready.

    1 to 2 weeks

  5. Run and improve

    Support with agreed response times, live ops for games, and a roadmap for what comes next.

    Monthly agreement

Focused by design.

A small number of projects at a time, each with a single point of accountability from the first call to launch.

Technologies we work with

Web and back end
TypeScript, React, Next.js, Node.js, .NET, Python
Data
PostgreSQL with partitioning and sharding, MongoDB, DynamoDB, Cassandra, Redis, ClickHouse, Elasticsearch
Streaming
Kafka, RabbitMQ, NATS; event-driven and CQRS architectures
AI
Any leading model provider or open-weight model, chosen per task; vector search; evaluation tooling
Mobile apps
Swift, Kotlin, React Native, Flutter
Cloud
AWS, Azure, Google Cloud, Cloudflare
Infrastructure
Kubernetes, Docker, Terraform, Helm; OpenTelemetry, Prometheus and Grafana for observability
Games
Unity, Godot, PixiJS, Phaser, three.js

Decisions are made where the code is written, without layers in between.

When a project needs more depth, such as technical art, a device lab or a platform specialism, we add it for exactly as long as the work requires, from specialists we have shipped with before. One contract, one point of contact, and no overhead the work doesn't need.

Questions we hear first.

How do you scope and price a project?

Discovery comes first, at a fixed fee agreed before we start. It produces a written specification, and from that we quote each phase at a fixed price, or set up a monthly agreement for products that keep evolving. On the first call we'll give you an indicative range and tell you if a smaller first version would serve you better.

Can you take over an existing codebase?

Yes. It begins with the fixed-scope audit described under inherited codebases, and ends in a written recommendation with the reasoning behind it.

Who owns the code?

You do. Source code, designs, assets, store accounts and cloud infrastructure are in your name, and intellectual property transfers to you as each phase is paid.

What happens after launch?

You can keep us on a monthly agreement for support, improvements and live ops, or take the project in-house. Either way you receive full documentation and a handover session, so the choice stays yours.

Do you work with publishers, or directly with studios and brands?

Both. We build original titles for studios and brands, and work with publishers on prototypes, production and live ops.

Do you sign an NDA before we talk details?

Yes. Send yours or ask for ours, and we'll sign it before the first detailed conversation.

Where are you based, and which time zones do you cover?

We're based in Europe and work with clients internationally, in English. We keep regular overlap with UK, US East Coast and Middle East working hours.

How soon can you start?

Discovery can usually begin within two to three weeks of the first call. We take on a small number of projects at a time, so we'll tell you on that call if the date is later.

It starts with a few exact lines.

Tell us what you're building.

A short description is enough. We reply with questions or a time to talk.

Prefer email? [email protected]

What do you need?

Nothing is sent until you press send there. We use your details only to reply.