Skip to content
All services

Managed app operations

Your app works.
We take on what comes next.

You made it with Claude, ChatGPT, Cursor, Lovable, Bolt, Replit or v0, and it works. Next it has to run in production, where people rely on it. We put it there and look after it: tested backups, monitoring, 24/7 on-call, a security review and deployments from Git.

Server management, for the apps people build now. We agree the work, price and running costs before we start.

From it works to it runsYour app, made with ChatGPT, Claude, Cursor, Lovable, Bolt, Replit or v0, goes into a Git repository, the source of truth. These stay yours, with your code, domain, data and accounts. From there we run it: a review of keys, access and backups, then a deploy, where Argo CD keeps Kubernetes running what is in Git, then live, for your customers. From then on: monitoring, an alert and OpsHelp on call 24/7, and backups with a restore test.Yourscode, domain, data, accountsYour appChatGPT Claude Cursor LovableBolt Replit v0Git repositoryThe source of truthReviewKeys, access, backupsDeployArgo CD keeps Kubernetesrunning what is in GitLiveYour customersWe runFrom then onMonitoringAlertOpsHelp on call 24/7BackupsRestore test

What next

What tends to go wrong once it works.

An app that works on your laptop or a preview link still has some way to go before people can rely on it. These are the common gaps, and what we do about each.

No backups
Your customers' data lives in one place. If it is deleted by mistake, or an update damages it, there is nothing to go back to.
What we doBackups run on a schedule and are kept away from the app. We restore one to prove it works, and repeat the test.
No backups, before and afterBefore: the data lives in one place. After: copies kept away from the app, with one restored as a test.One placeRestore tested
Keys in the code
The key you pasted in to get it working is still in the code, or in what the browser downloads. Anyone who finds it can use that service on your account.
What we doA security review of your own app looks for them. Keys and passwords move into a secrets store, and any that were exposed are replaced.
Keys in the code, before and afterBefore: a key pasted into the code. After: the key held in a secrets store, out of the code.KEY="x7Q…"In the codeSecrets store
Nobody watching it
If the app stops on a Sunday night, the first you hear of it is a customer telling you.
What we doMonitoring checks that the app is up and answering. When it is not, OpsHelp is paged, whatever the hour.
Nobody watching it, before and afterBefore: the app stops and the line goes quiet. After: the app stops and OpsHelp is paged.App stopsOpsHelp paged
Deploys by hand
A new version goes live when you press publish or copy the files across. If it breaks something, there is no quick way back to the one that worked.
What we doThe app is deployed from Git, a way of working called GitOps. Your repository says what should be running, and a tool called Argo CD keeps it that way. The app itself runs in a container on Kubernetes, which restarts it if it falls over. Undoing a release means reverting a commit.
Deploys by hand, before and afterBefore: files copied across by hand, straight to the live app. After: releases as commits in Git, with a way back to the one before.By handA way back
One person holds the accounts
The domain, the hosting and the database sit under your own login. If you are ill or away, nobody else can get in.
What we doWe help you put them in the business's name, give each person their own access and keep a written record of where everything is.
One person holds the accounts, before and afterBefore: the domain, the hosting and the database under one login. After: the accounts in the business's name, with each person given their own access.One loginThe business

The security review also looks at what is harder to see from outside: who can read the database, and which parts of the app change data without checking who is asking.

You choose where the app runs, and we agree the work and the price before we start.

Worked example

Follow one app from your repository to a 3am alert.

Say you made a booking app for a bike repair shop. Customers book a slot, pay a deposit and get a reminder. It has real customers, and you are the only person who knows how it works. This is what happens when you hand us the running of it.

Stage 06 · Something breaks at 3am

When something breaks: who does what, in order1. Bookings start failing, and monitoring notices. 2. Kubernetes restarts the container on its own. 3. If the errors carry on, the alert pages OpsHelp. 4. We work through the runbook: see what changed, 5. then roll back to the last release that worked. 6. You decide: anything that could lose data, such as restoring from a backup, waits for you unless the runbook already covers it. 7. A write-up afterwards: what happened, what we did and what we will change to make it less likely to happen again.1MonitoringBookings start failing, andmonitoring notices.2KubernetesKubernetes restarts the container onits own.3MonitoringIf the errors carry on, the alertpages OpsHelp.4OpsHelp on callWe work through the runbook: see whatchanged,5OpsHelp on callthen roll back to the last releasethat worked.6You decideAnything that could lose data, suchas restoring from a backup, waits foryou unless the runbook already coversit.7OpsHelp on callA write-up afterwards: what happened,what we did and what we will changeto make it less likely to happenagain.

The six stages

  1. Your app arrives

    Comes in
    Read-only access to your Git repository, a note of where the app runs today, and the services it relies on: database, sign-in, payments and email.
    We do
    Read the code, the configuration and the deployment settings. Nothing is changed at this stage.
    You get
    A short list of anything else we need to see.
    You decide
    What we may look at. We only review systems that are yours, with your written go-ahead.
  2. We check it

    We do

    We go through the app against the same list every time. First the five gaps above: backups, keys, monitoring, deployments and who holds the accounts. Then three that are harder to see from outside.

    Database access
    Row-level security switched off or too generous, and file storage that anyone with the link can read.
    API routes
    Endpoints that change data without checking who is asking.
    Updates
    Packages still at the versions they had on the day the app was generated.
    You get
    A written review in plain English: what we found, what matters most and what we would fix first.
    You decide
    Which fixes go ahead, and in what order.
  3. We fix what we found

    We do
    Move keys out of the code and the browser into a secrets store. Tighten the database rules, then sign in as an ordinary customer to confirm that one person cannot read another's bookings. Add sign-in checks to the routes that need them. Set up backups and restore one to prove it works. Bring the packages up to date.
    You get
    Each fix as a pull request in your repository, with a note of what it changes and why. Keys that were exposed are replaced, and we walk you through any that only you can reissue.
    You decide
    You approve each change before it goes live, or agree in advance which kinds we can make without asking.
  4. We put it into production

    We do
    Package the app as a container and set up deployment from Git, so Argo CD keeps Kubernetes running the version in your repository. We set up the domain, the certificates and the email the app sends, so booking confirmations have a proper sender behind them.
    You get
    Releases you can trace to a commit. Undoing one means reverting that commit.
    You decide
    When the switch happens. We rehearse it first.
  5. We watch it

    We watch
    Whether the app is up and answering. Error rates. Certificate and domain renewals. Database and disk growth. Whether last night's backup ran. Security advisories for the packages it uses, patched through Git like any other change.
    You get
    A plain report of what happened, what we changed and what we recommend next.
    You decide
    Nothing, unless something needs you.
  6. Something breaks at 3am

    Comes in
    Bookings start failing, and monitoring notices.
    We do
    Kubernetes restarts the container on its own. If the errors carry on, the alert pages OpsHelp. We work through the runbook: see what changed, then roll back to the last release that worked.
    You get
    A write-up afterwards: what happened, what we did and what we will change to make it less likely to happen again.
    You decide
    Anything that could lose data, such as restoring from a backup, waits for you unless the runbook already covers it.
    Cover
    Monitoring runs all the time. On-call is 24/7, and OpsHelp is who gets paged.

What stays yours

It is still your app.

Handing over the running of an app does not mean handing over the app. We run it wherever you want it: in your own cloud account, with a provider you choose or on your own servers.

If you want a sovereign setup, we run that too, sovereign AI included, so the app, its data and any AI it uses stay under your control.

What stays yours, and how we reach itYour code, domain, data and accounts stay yours. OpsHelp runs the app through named access, and you can remove it.YoursCodeDomainDataAccountsNamed accessYou can remove itOpsHelpWe run it
Code
The repository is yours, and every change we make is in it.
Domain
Registered to you or your business, with the DNS under your control.
Data
Yours, with a copy whenever you ask for one.
Accounts
Yours, in your own or your business's name. Our access is named, and you can remove it.
If you leave
We hand over the runbooks and remove our own access.

Agents and automations

Agents are apps too.

If you have built an agent or an automation yourself, it is one more kind of app. It gets the same care: its code in Git, its keys in a secrets store, backups, monitoring and someone on call.

Would you rather have one built for you? That is our workflow automation service.

Three things we check on top

A spending limit
A ceiling on model usage, so a loop has somewhere to stop.
A record
A log of what the agent did, for when a result looks wrong.
A stop
A way to stop it quickly, and a person who knows where it is.

Where one is missing, we add it.

Why trust us with it

Server management, for the apps people build now.

This is the work OpsHelp already does. We run production systems for news sites with large audiences and for agencies: servers, backups, updates and the call when something breaks.

An app made with AI needs the same care. It usually runs in containers or on a cloud platform rather than on traditional web hosting, so that is where we look after it.

We are based in Nottingham and work with clients across the UK.

Read what other clients say

From a client whose servers we manage

Managing a high-traffic media platform requires an infrastructure partner you can trust. OpsHelp has been that partner for us. They handle our server management, optimisation, and security with incredible responsiveness, allowing our editorial team to focus on content without worrying about downtime. Highly recommended for anyone needing serious reliable hosting.
The Canary
Independent Media Platform

Who it suits

  • Founders who vibe-coded an app that now has real users, and nobody to run it.
  • Small teams whose one developer would rather build than be on call.
  • Agencies that ship apps for clients and want someone behind them, under the agency's name if they prefer.
  • People who are not engineers and have built something that matters.

Price

What it costs, and how it starts.

There is no published price, because it depends on the app: what it does, how much traffic it gets and how much there is to look after. We agree the work, price and running costs before we start.

You can start with a focused piece of work, such as the review, rather than committing to ongoing management.

  1. Tell us about the app

    What it does, what you made it with, where it runs and what worries you. The first conversation is free.

  2. We agree the work

    What we will do, what it costs and what the running costs are, in writing, before anything changes.

  3. We review and fix

    With read-only access first. Changes follow once you have seen the review.

  4. We run it

    Production, monitoring, patching and 24/7 on-call.

Common questions

Questions about handing over your app

Does my app have to move?
Not unless you want it to. It can stay where it is or go to your own cloud account, a provider you choose or your own servers. If where it runs today makes backups, access or deployments hard to control, we say so in the review, and you decide.
I am not technical. Will I understand what you are doing?
Yes. The review, the reports and every incident write-up are in plain English, and each change is listed so you can see what happened to your app.
Do you fix bugs or build features?
We fix what stops the app running properly in production: configuration, secrets, access rules, deployments and updates. The product itself stays with you. If a bug is behind an outage, we show you where it is and what would fix it.
Can I keep building while you run it?
Yes, that is the idea. You, your developer or your AI tool keep working in the same repository. Changes reach production from Git, so a bad release can be undone.
Will my app be secure once you are running it?
No one can promise that an app will never be attacked or never go down. What we do is check it, fix what we find, keep it updated, watch it and act when something happens.
Can you work with my developer or agency?
Yes. We agree who does what, and we can work under your agency's name if that suits you.

Not an app you built?

If you look after a server, a hosting account or a fleet of client sites, that is server management, with plans on the managed hosting page. For a WordPress site, see the WordPress care plans.

Talk it through

Tell us about your app.

What it does, what you made it with, where it runs today and what worries you most. We will tell you what we would look at first.

Leave passwords and keys out of the message. We agree a safe way to share access after we have spoken.

Send an enquiry at any time. We will respond as soon as we can and agree a practical next step with you.

Tell us about your app