Software maintenance and support, including apps another team built
We take over Python, Django, FastAPI, React, SvelteKit and Flutter products, fix what is urgent, keep frameworks and dependencies current, and keep building features on a monthly retainer. It starts with a fixed-scope Takeover Assessment, and you can stop with 30 days' notice.
- 12+ years experience
- 50+ projects delivered
- Month to month, 30 days' notice
- You own all code & IP
Sounds familiar?
Most maintenance work starts in one of these places. All of them can be fixed without starting over.
The developer or agency is gone
The person who built it left, and most of what they knew left with them.
Nobody wants to deploy
Releases are rare because every deploy might break something.
Your framework is out of support
Django, Python or Node is past end of life, and security reviews keep flagging it.
Nobody answers when it breaks
Issues wait for days because no one owns the system.
The backlog has stalled
Customers ask for features your team never gets to.
An AI-built app now has real users
It was built fast with AI coding tools, and now it holds customer data.
What the retainer covers.
One monthly retainer for all four kinds of maintenance. You decide each month how the time splits between keeping the system healthy and building new things.
| Kind | In plain words | Examples |
|---|---|---|
| Corrective | Fixing what breaks | Bugs, failed jobs, broken integrations, production incidents |
| Adaptive | Keeping up with the world around the app | Framework and runtime upgrades, browser and OS changes, third-party API and AI model changes |
| Preventive | Stopping the next incident | Security patches, dependency updates, monitoring and alerts, backups with tested restores, tests |
| Perfective | Making it better | Performance work, new features, roadmap items from your backlog |
How a takeover works.
It works whether or not the previous developer is reachable. If they are, we record a walkthrough with them; if not, the assessment reconstructs what we need from the code and the hosting.
- 01 / 04
1 to 2 weeks
Takeover Assessment
A fixed-scope first step. We move access into your accounts, build and deploy the app from a clean checkout, list every dependency and end-of-life date, review security and tests, and hand you a written risk list and first-month plan.
- 02 / 04
First month
Stabilise
Rotate secrets, prove the backups by restoring them, set up CI, a staging copy, monitoring and alerts, and a one-step rollback, so changes stop being risky.
- 03 / 04
Every month
Maintain and build
Fixes, updates and features from one shared backlog, with a weekly written update and a monthly report of what shipped and what is next.
- 04 / 04
Every quarter
Review and plan
What changed, what is at risk, and the upgrades to schedule before your framework or runtime reaches end of life.
What you get in writing.
Knowledge that lives in one person's head is how apps get stranded. Everything we learn about your system is written down and stays with you.
- 01
Access map
Every repository, server, domain, store and third-party account, with the owner moved to you.
- 02
Runbook
How to build, deploy and roll back, written so any engineer can follow it.
- 03
Dependency and end-of-life register
Every framework, runtime and library, its version and the date it goes out of support.
- 04
Risk list
Security, data and reliability risks, ranked, with the fix for each.
- 05
Prioritised backlog
Fixes, upgrades and features in one list you control.
- 06
Monthly report
What shipped, what broke and why, and what is planned next.
How urgent issues are handled.
Every issue gets a severity, and the severity decides what happens next. Response targets and support hours for each level are agreed before we start and written into your agreement.
| Severity | What it means | How we handle it |
|---|---|---|
| Critical | Production is down, data is at risk, or customers cannot use the core of the product. | Worked on first, ahead of everything else, until it is resolved or safely rolled back. |
| Major | An important feature is broken and there is no reasonable workaround. | Fixed in the current cycle, ahead of planned work. |
| Minor | Something is wrong but people can work around it. | Scheduled into the backlog by priority. |
| Request | A change, improvement or new feature. | Planned with you from the backlog each month. |
Ways to keep an app running.
The honest comparison. A retainer is not always the answer; this is how the common options differ.
| Question | Hire in-house | A freelancer | Paid extended support | A maintenance retainer with us |
|---|---|---|---|---|
| Time to start | Often months to hire, then onboarding | Days to weeks | Days | A 1 to 2 week assessment, then monthly work |
| When a person leaves | Knowledge leaves unless written down | Work stops | Not affected | Covered by a team, with the runbook and reports in writing |
| Framework upgrades | If there is time | Depends on the person | Security patches for an old version, no upgrade | Planned ahead of end-of-life dates |
| New features | Yes | Yes, as capacity allows | No | Yes, from your backlog every month |
| Best for | Products with steady full-time work | Small, low-risk changes | Buying time before an upgrade | Products that need steady fixes, upgrades and features without a full-time hire |
Keep, stabilise, upgrade or rebuild?
The assessment ends with one of these four recommendations. Most apps are worth keeping; we recommend a rebuild only when it costs less than keeping the code.
Keep and maintain
- Signals
- It works, people use it, and changes are slow but safe.
- Next step
- Go straight to the monthly retainer after the assessment.
Stabilise first
- Signals
- It breaks often, there are no tests or CI, and every deploy is a gamble.
- Next step
- A stabilisation month, then the retainer.
Upgrade
- Signals
- The framework or runtime is out of support, or security reviews keep failing on old versions.
- Next step
- An upgrade project in stages.
Rebuild
- Signals
- The stack can no longer be supported, or the product has outgrown it, and patching costs more than replacing.
- Next step
- A phased rebuild that keeps the old system running until the new one is ready.
We already work this way.
We run and maintain our own products and open-source libraries, so a retainer is how we already work, not a new line of business.
MedOnGo
An Indian primary care platform. In 2026 we worked on its clinic backend, Flutter patient and doctor apps, kiosk and device software, and analytics.
Read moreOnlineCompiler.io
A code execution API for 46 languages that we build and run ourselves: 1,900+ developer accounts and about 45,000 runs a month.
Read moreOpen-source libraries
We have maintained forex-python, Django-CRM and other open-source projects for years, in public, for anyone to inspect.
Read moreGood fit for
- custom web apps, APIs, SaaS products and Flutter apps on Python, Django, FastAPI, React, Next.js, SvelteKit or Angular
- products whose original developer or agency has left, with or without a handover
- teams that want their own engineers on new work while someone else keeps the system healthy
- apps built quickly with AI coding tools that now have paying users
Not the right fit
- WordPress, Shopify or Wix care plans
- placing an engineer inside your team to take instructions day to day
- apps where nobody can give access to the code or the hosting
Running a healthcare platform? See healthcare software development. Page updated .
Frequently asked questions.
Straight answers to what founders and CTOs ask before handing over an app they did not build.
Can you maintain an app you did not build?
Yes. Most of our maintenance work starts with code another team wrote. We begin with a fixed-scope Takeover Assessment: we get the app building and deploying from a clean checkout, map every account and dependency, review security and tests, and give you a written risk list and plan before any monthly work starts.
The original developer is gone and there is no documentation. Can you still take it on?
Yes. If you can give us access to the code and the hosting, we can work out the rest; reading undocumented code is a normal part of the assessment. If the previous developer is reachable, we record a walkthrough with them, but we do not depend on it. The documentation we write during the takeover becomes yours.
What access do you need, and who owns the accounts afterwards?
We need the code repository, hosting or cloud account, database access, domain and DNS, and any app store or third-party accounts the product uses. Everything stays in, or is moved into, accounts your company owns. We work through named accounts you can revoke at any time, and you own all code and intellectual property.
How quickly can you start, and what happens in the first month?
The Takeover Assessment takes one to two weeks. The first month after it is stabilisation: rotating secrets, testing backups by restoring them, setting up CI, staging, monitoring and a one-step rollback, and fixing the most urgent risks. Regular monthly fixes and feature work follow.
Will you tell us to rewrite it?
Only if the assessment shows that a rebuild costs less than keeping the code, and most apps are worth keeping. We usually stabilise first, add tests around the parts that change most, and upgrade in stages. If a rebuild is right, we do it in phases while the old system keeps running.
Our Django or Python version is out of support. Do you upgrade it or just patch it?
We upgrade it. Paid extended-support patches can buy time, but they leave you on an old version. We plan the upgrade in stages, with tests first so regressions are caught, and keep a register of end-of-life dates so the next upgrade is scheduled before it becomes urgent.
What does a maintenance retainer cover?
Fixes and incidents, security patches and dependency updates, framework and runtime upgrades, monitoring, backups with tested restores, performance work, and new features from your backlog. You decide each month how the time splits between keeping the system healthy and building new things.
What happens when production breaks?
Issues are handled by severity. A critical issue, such as the product being down or data at risk, is worked on ahead of everything else until it is fixed or safely rolled back. Response targets and support hours for each severity are agreed before we start and written into your agreement.
How do you keep our code, data and accounts secure while you work?
We work inside your accounts and repositories with named, least-privilege access you can revoke, keep secrets in a managed vault rather than in code, use test data instead of real customer data wherever the task allows, and log access to production. We answer your security questionnaire in writing before access is granted.
How do we avoid being locked in to you?
The retainer runs month to month with 30 days' notice. Your code, accounts and documentation stay in your hands the whole time, and the runbook, access map and monthly reports are written so another team, or your own hire, can take over from us at any point.
Can you work alongside our in-house developers?
Yes. A common setup is your team building new product while we keep the system healthy: upgrades, fixes, monitoring and the backlog they never get to. We work in your repositories and tools, through your normal review process, with a weekly written update.
What drives the cost of a maintenance retainer?
The size and age of the codebase, how much test coverage it has, how many integrations it depends on, how often you release, the support hours you need, and how much new feature work you want each month. We quote a fixed monthly fee after the Takeover Assessment, so you know the cost before the retainer starts.
Our app was built quickly with AI coding tools. Can you make it safe to keep running?
Yes. AI-built apps often work in a demo but lack tests, access controls and safe deploys. The assessment finds the risks, the stabilisation month fixes the urgent ones, and the retainer keeps the app maintained as you add users and features.