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.
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.
- 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.
- 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.
- 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.
- 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.
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
The six stages
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.
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.
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.
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.
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.
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.
- 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 sayFrom 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.
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.
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.
We agree the work
What we will do, what it costs and what the running costs are, in writing, before anything changes.
We review and fix
With read-only access first. Changes follow once you have seen the review.
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.