10x Works Book a free assessment

Software development that never sleeps. One fixed monthly price.

A factory of AI agents works in parallel on your apps and sites around the clock. Your requests start the moment you send them; maintenance and improvements happen without you asking. Senior engineers oversee the factory and sign off every change that reaches your customers.

Show me what's possible

Twenty minutes. Tell us what your software does and what you wish it could do. We'll tell you how we make that possible and what it costs. No obligation.

Sound familiar?

Whoever you hire, something has to give.

  • PriceNothing serious starts below £1,000 a month, and it only gets more expensive. Two days a week of a good contractor is £4,000 a month. Want more done? You'll need to keep paying more.
  • ReliabilitySomeone who is reliably there costs full-time money — a salary, or an agency retainer. Everything cheaper is someone with other clients, other priorities, and a phone they can stop answering.
  • ScopeWhatever you buy is capped before you start. The list of things you'd like done is always longer than the days you've paid for, and it grows faster than they get closed.
  • SpeedAn agency books you in for next month. A fractional developer has Tuesdays. A full-time hire gets more done faster, but costs £65k a year and comes with all the other issues that come with full-time employees.
  • MaintenanceUpgrades, monitoring, the page that takes six seconds to load — never beats a feature a customer actually asked for, so it never gets done.

Every one of these is the same constraint in a different coat: you are buying someone's hours, and that someone does one thing at a time. That's why the price moves in a straight line, and why the list never gets shorter. Until recently there was no other way to do it. That's all changed with Works.

Show me what changed

What changed

Nothing has to give.

All five constraints exist for one reason: you were buying a person's hours. You aren't any more.

  • Price

    One monthly price, fixed in advance. A quiet month and a crazy month cost the same.

  • Reliability

    No ski trips, no notice period, no better offer elsewhere.

  • Scope

    Send everything. Think big without watching the bill.

  • Speed

    Work starts the moment you send it. Not next sprint, not next month.

  • Maintenance

    The work that never gets done? Done already.

Show me what I'd pay

How it works

A factory on your code, with senior engineers at the controls.

  1. Assess

    We go through your code, your tooling, how your team works and what you hope to achieve. You get a straight report and a price, whether or not you go ahead.

  2. Configure

    We stand up a factory on your code: monitoring, automated review and QA, your channels (email, Slack, WhatsApp) and your systems (Linear, Jira, ClickUp) all wired in.

  3. Run

    Work ships continuously and you can ask for as much as you like. Every change is independently reviewed, tested and deployed safely — that's how fast stays safe. Errors get caught and fixed before you notice them, and your tickets and docs update themselves as the work goes through.

  4. Oversee

    Everything shows up on your dashboard, and the big calls wait for your one-click approval. Senior engineers own every decision.

Getting there is hands-on. Expect a lot of us in the early weeks, on calls and asking questions about how you work — as many touches as it takes to get the factory humming. The machine gets quieter as it learns. We don't go anywhere.

The dashboard

A board that can't go stale.

Every board you've ever been shown was maintained by someone who had better things to do, so it was out of date the moment you looked at it. This one is the factory's own state, published as the work happens. Your tickets stay wherever you already track them. Nothing touching money, logins or customer data ships without your say-so, and saying yes takes one click.

your-app · factory1 decision waiting

Queued 4

requested · by you, on WhatsAppAdd a "reorder last month" button to the customer portal
proposed · by the factoryUpgrade the payment library before the old version stops getting security fixes
proposed · by the factoryThe reports page loads in 6 seconds; it can load in one

Shipping 2

building · review passed · tests greenExport bookings to a spreadsheet
caught overnight · fixed · on stagingInvoice emails failed for customers with an apostrophe in their name

Needs your yes 1

risk gate · touches paymentsChange the refund flow so partial refunds are allowedApprove · Reject · Ask a question

An illustration. You'll see the live dashboard, working real tickets, on the call.

Walk me through it

Pricing

A fraction of one developer's salary. None of the hiring risk.

We look at your code, your tooling and your team, then place you in one of four plans. Moving up buys more senior human attention on your work — the machine runs the same at every level.

PlanWhat it coversPer month
Workshop One app, and you're the person we talk to. Everything reviewed, tested and QA'd automatically; senior sign-off on anything that touches risk. £500
Line An app and a front end, a handful of people in the loop. Adds senior steering on what to build next, and a human scan of every significant change. £1,500–2,500
Plant Several codebases and a team we work alongside. Adds hands-on QA of complex and UI-heavy work, custom integrations, priority throughput, and infrastructure dedicated to you. £5,000
Programme Several factories across teams and products. Adds your own hardware or cloud, non-standard tooling, and senior advisory time. £10,000and up
  • Onboarding: one month's fee waived for early clients.
  • All plans: flat monthly, billed in advance, pause or cancel anytime — and everything we've built is yours to take.

How we can charge this

You're not buying hours. Most of what a developer's day costs isn't thinking — it's typing, waiting, chasing, writing the ticket up afterwards. The factory does all of that, so the senior time you pay for goes on decisions and review. No sales team, no project managers, nobody on the bench. And every factory is built from the same machinery, so you're not paying us to invent it.

Tell me where I'd sit

Security

The machine can't go rogue.

  • It can't reach production.The factory holds no production credentials and no deployment keys — both live outside it. Nothing it builds goes live until a human turns a key, and when production access is genuinely needed a person does it by hand from a separate machine. Can the AI see your customers' data? No — structurally.
  • How much it may do unattended is a dial you set.Per environment, from locked down at one end to fully automated at the other. You move it as trust builds, and you can move it back.
  • Anything risky waits for a human.Payments, authentication, customer data — senior review before it ships, on every plan including the cheapest.
  • Separation is absolute, and it's free.Every client gets their own isolated workspace, their own credentials and their own code storage, on every plan. Access is least-privilege, issued from your own accounts, and revocable by you in one click. What the higher plans buy is dedicated hardware — your own VM at Plant, your own machines or cloud at Programme.
  • Everything is written down.Every action, decision and deploy is journaled. You can read it, and you keep it. Try asking a traditional agency for their complete work log.
  • Your code trains nothing.Our model providers are contractually barred from training on anything we send them.
  • UK company, English law.Contracts you can read, with a named person accountable for them.

New builds

Starting from scratch? Same subscription.

No project fee, nothing upfront. You start the subscription and your app gets built inside the factory — reviewed, tested, documented and monitored from its first commit. When it goes live, nothing changes hands: the machine that built it carries on running it.

What you're buying is time, not scope. An agency fixes the scope and the price, then the timeline slips and every change becomes a negotiation. Here the monthly price is fixed and the only variable is how many months — so changing your mind costs nothing, and you can stop whenever you like. A build runs on the plan the work needs; once it's live and settled, you can usually move down.

We'll tell you roughly how long we think it'll take. We won't pretend to know exactly.

Tell me how long mine would take

Questions

The things people ask before they book.

Is this AI slop?
Agents do the throughput and automated reviewers check every line. Anything touching payments, authentication or your data gets senior human review before it ships, on every plan. And where work needs taste — design, mostly — a person does it, because AI is still poor at that and we'd rather say so than pretend. Ask us where the human line sits and we'll show you on the call.
How much can I actually ask for?
As much as you like. We don't count requests, and the factory works on many at once. There's one line: your existing product evolves freely, but a brand-new product alongside it gets scoped as a project — and the subscription runs it afterwards. Without that line, £500 a month would buy a whole new app, and we'd both know that wasn't right.
How fast is it?
Small things the same day. Bigger things in days, not weeks. Work starts the moment you send it, so nothing sits in a queue waiting for someone to be free — and when something is going to take longer, you'll see that on the board rather than wondering.
What if my app's a mess?
Most of them are, and it doesn't change the price. The assessment tells you what state it's in and what we'd fix first. Tidying up is part of the work, not an extra.
What stacks do you work with?
Rails and Ruby, JavaScript and TypeScript, PHP and Python first. The assessment tells you within a week whether yours fits.
We already have a developer.
Good. We're the capacity behind them, and the continuity plan if they leave. If you're an agency, white-label terms exist, so ask.
How much human attention do we get?
As many touches as it takes, and more as you move up the plans. Onboarding and the early weeks are deliberately high-touch — calls, walkthroughs, a lot of questions about how your business works. The factory gets quieter as it learns; the reporting and the proposals don't stop, and neither does the senior engineer on the other end of your channel.
What if you disappear?
Everything in your code and accounts is yours, and the factory's first job is documenting it fully, so any developer could pick it up tomorrow. The developer who vanished with the keys can't happen here. The keys were always yours.
What happens when I pause?
Your factory stops and so do your invoices. Your code, documentation and accounts stay yours throughout, and we hold nothing back. Restart whenever you like. If the code moved on while we were away, the first week back is a short re-assessment.

Why this exists

Twenty years of building software, seven of them running an agency, and the same conversation over and over: someone with a business that runs on an app, and no sensible way to look after it. The quotes were too big. The freelancers disappeared. And the option everybody actually wanted — a senior developer who knows your system and is always there — cost more than the business could justify.

For most of those twenty years, that was simply true. It stopped being true recently, and faster than most people have noticed. Agents got good enough to do the work, provided someone experienced sets them up, checks what comes out, and owns the result. So we built the thing we'd never been able to sell: the developer who never leaves, at a price that isn't a salary.

We're taking on our first clients now. If your software needs looking after, the assessment is free, and we'll tell you the truth about what we find.

Find out what your software needs.

You've been putting things off because every option costs too much, takes too long, or leaves you depending on one person. Twenty minutes will tell you whether that's still true.

Book the twenty minutes