Services / Maintenance & Support
Someone who knows
your system, on call
Ongoing support and development for custom software — ours or somebody else's. Monitoring, fixes, updates and new features under a monthly agreement, with response times in writing.
Already have a problem right now? Say so in the message and we'll reply today — emergency help doesn't require a contract first.
Overview
Why people end up here
The moment software
stops being someone's job
The agency that built it moved on
Tickets go unanswered for weeks, and nobody there is really looking anymore.
One freelancer knows the whole system
…and he's on holiday. Everything that matters lives in one person's head.
Something breaks and nobody can tell you if it's serious
No monitoring, no context — every incident is a guess about how bad it is.
The libraries are three years out of date
Updating them now scares everyone, so the gap keeps getting wider.
Nobody's tested a backup restore since launch
Including the restore itself — the backup is a hope, not a guarantee.
Small changes cost more than they should
Someone has to relearn the code first, every single time.
Your developer is fully booked with new features
So maintenance is always the thing that gets done next month.
You found out about the outage from a customer
The people who should have seen it first didn't see it at all.
None of this needs a rebuild. It needs someone whose job it is to notice.
Who this is for
Five situations we take over
We support software we built and software we didn't. Taking over someone else's codebase is a normal part of what we do, not an exception we grumble about.
Abandoned by the previous vendor
They stopped responding, went out of business, or quietly moved you down their priority list. We audit, stabilise and take the system on.
Built by one person who's gone
A contractor, a former employee, an agency of one. No documentation, no handover. We reconstruct how it works before anything else.
Working, but nobody's watching
It runs fine today. There's no monitoring, no backups you've tested, no update path. This is the cheapest possible moment to fix that.
We built it, and it keeps growing
Ongoing development, new features and care under one predictable monthly agreement.
Your team needs backup
Your developers exist but are fully booked. We take the maintenance layer so they can build.
Not sure which of these you are? Start with an audit. You'll get a written verdict on your system's condition and the specific risks in it — useful whether or not you continue with us.
What's guaranteed,
in writing
- < 1h
- Critical response, written into the contract
- 24/7
- Monitoring and alerting on every plan
- Monthly
- A report you can actually read
- 30 days
- No lock-in — notice, then a full handover
What's included
What "maintenance"
actually means here
Not a mailbox that receives complaints. A defined set of work that happens every month whether or not anything breaks.
Monitoring and incident response
You find out from us, not from your customers.
- Uptime, error rate and performance monitored continuously
- Alerts that reach a person, not a dashboard nobody opens
- Response times defined by severity and written into the agreement
- Out-of-hours contact on higher plans — real phone numbers, not a form
- A written post-incident summary: what happened, why, what prevents a repeat
Fixes and support requests
One place to report a problem, and a clear answer on when it'll be dealt with.
- Single channel — ticket system, email or Slack, whichever your team will actually use
- Every request triaged by severity and answered, including "we won't do this and here's why"
- Bugs fixed at the root, not patched around
- Questions from your team answered too, not only defects
- A backlog you can see, so nothing lives in someone's head
Security and dependency updates
The work that's invisible right up until it isn't.
- Libraries and frameworks kept current, in small steps instead of one terrifying jump
- Security advisories tracked and patched, with urgency matched to real exposure
- Certificates, secrets and access reviewed on a schedule
- Penetration test findings triaged and fixed
- OS and platform version changes handled before they force your hand
Backups you've actually tested
An untested backup is a hope, not a backup.
- Automated backups with a documented retention policy
- Restore tested on a real schedule, and reported
- A written recovery procedure, with a realistic recovery time
- Off-site or second-region copies where the risk warrants it
Performance and cost optimisation
Faster software and a smaller invoice from your cloud provider.
- Slow queries and endpoints found and fixed
- Caching, indexes and infrastructure sizing reviewed
- Cloud spend audited — most systems pay for capacity they don't use
- Reported as before-and-after numbers, not adjectives
gateway5/5
Technical debt, in planned instalments
The code gets better over time instead of worse.
- A prioritised list of what's fragile and what it costs you
- A fixed share of each month spent on it, agreed with you
- Refactoring done alongside features, not as a project you'll never approve
- Tests added where breakage would hurt most
Ongoing development
Because a system that stops changing starts getting worked around.
- Included development hours every month for real changes, not just fixes
- Small requests handled without a quote and a contract each time
- Larger features scoped and priced separately, with the same team
- A quarterly conversation about where the system should go next
Documentation and no single point of failure
The problem you have now, prevented for next time.
- How the system works, written down — architecture, integrations, deployment
- Runbooks for the situations that recur
- At least two of our people know your system, always
- Everything in your accounts and your repository
Reporting you'll actually read
Not a PDF nobody opens — the four numbers that matter and what to do next.
- A monthly summary: uptime, incidents, what changed, what we recommend next
- Hours used and what they went into
- Risks flagged early, with the cost of ignoring them
- A quarterly review call, not a document nobody opens
Need something that isn't listed? Most plans get shaped around the system, not the other way round. Tell us what keeps you up at night.
Talk to UsWhat we can take over
React, Next.js, Node, TypeScript, React Native, PostgreSQL, MySQL, Docker, AWS, Azure, Vercel, Supabase, plus WordPress and PHP systems where the job is stabilising rather than rebuilding. If your stack isn't here, ask — and if we're not the right people for it, we'll say so rather than learn on your budget.
Takeovers
Systems we inherited
Three systems we didn't build, taken over and stabilised. Anonymised — nobody wants to be publicly identified as the company whose software was falling over.
No docs, 40 outdated dependencies, an outage every fortnight
First 30 days: monitoring and alerting stood up, backups fixed and restore-tested, the two dependencies causing the outages patched. Now: still under care, no unplanned outages in the last quarter.
Two vendors had quoted a full rebuild
First 30 days: audit and written verdict — the system was worth keeping, not replacing. We stabilised the worst of it and mapped what would eventually need work. Now: running on a monthly plan, rebuild avoided.
Built by one contractor who had left the company
First 30 days: reconstructed how the system worked, moved every repository, domain and cloud account into the client's ownership. Now: stabilised, documented, and handed to their own new hire in 2025.
Client feedback
What changed after the handover
40+
Systems under care
8 yrs
In business
99.9%
Average uptime
4.9/5
Average client rating
The previous agency took two weeks to answer an email. These people replied in twenty minutes on a Saturday, and it wasn't even critical.
E-commerce
Took over a platform after the original vendor closed
We'd been quoted a full rebuild by two companies. They stabilised what we had for a fraction of it and told us honestly which parts would eventually need replacing.
Logistics
Inherited a system with no documentation
The monthly report is the first thing I've ever received from a software company that I read all the way through.
Professional services
Ongoing care and development, third year
How we take over
From first call to covered
Taking on somebody else's system has a specific sequence. Skipping the audit is how support contracts turn into arguments in month two.
01
First call — 30 minutes
What the system does, what's broken, who built it, what access exists. If it's an active emergency, we deal with that first and talk about contracts afterwards.
02
Audit — 3–10 days
Code, architecture, dependencies, security, infrastructure, backups, data. Output: a written report with risks ranked by severity and cost of inaction.
03
The honest verdict
Maintain, refactor in stages, or replace. Sometimes replacing is cheaper than maintaining, and we'll tell you that even though the support contract is the easier sale.
04
Access and continuity
Repositories, servers, domains, certificates, third-party accounts — all moved into your ownership if they aren't already. This step alone resolves half the inherited problems we see.
05
Stabilisation sprint
The first month goes on the highest-severity items: monitoring, backups, critical security patches, whatever is actively failing.
06
Plan and SLA agreed
Hours, response times, channels, escalation path, named people. Signed, so nothing depends on goodwill.
07
Steady state
Monthly work, monthly report, and a quarterly review of where the system should go next.
Plans
Three levels of cover
Pick the level of attention the system needs. Every plan is monthly, every plan can move up or down, and the response times below are the ones we sign.
How pricing works
Start with an audit
A written verdict on the system's condition and its risks, priced by size. If you sign a plan, we credit it against your first month.
A plan sized to the system
Hours, response times, coverage and channels agreed from what the audit found — not from a package we'd rather sell.
Stabilise, then steady state
The first month goes on whatever is most fragile. After that it's monthly work, a monthly report and a quarterly review.
Essential
At a glance
- 4–8 hours a month
- Critical response: 4 business hours
- Business-hours coverage
For systems that work and need to keep working.
Price
From ~€490 / month
Included
- Monitoring, backups, security patches, dependency updates
- Monthly report
- Development work available at an hourly rate
Active — most popular
At a glance
- 20–60 hours a month, maintenance + new features
- Critical response: 1 business hour
- Named engineer, plus a second person briefed
For systems that keep developing.
Price
From ~€1,900 / month
Included
- Everything in Essential
- Quarterly roadmap review
- Technical debt reduction included, not deferred
Dedicated
At a glance
- 1 FTE and up: developer, QA and PM
- Critical response: 30 minutes, 24/7
- Out-of-hours phone contact, named people
For systems the business genuinely depends on.
Price
From ~€4,800 / month
Included
- Everything in Active
- Architecture and capacity planning
- Written SLA with credits if we miss it
Compare the plans
| Essential | Active | Dedicated | |
|---|---|---|---|
| Hours per month | 4–8 | 20–60 | 1 FTE+ |
| Critical response time | 4 business hours | 1 business hour | 30 min · 24/7 |
| High / medium response | Same business day | Same business day | Same business day |
| Coverage hours | Business hours | Business hours | 24/7 |
| Out-of-hours contact | — | — | Phone · named people |
| Monitoring & alerting | ✓ | ✓ | ✓ |
| Backups & tested restores | ✓ | ✓ | ✓ |
| Security patching | ✓ | ✓ | ✓ |
| Dependency updates | ✓ | ✓ | ✓ |
| Included development hours | At hourly rate | Included | Included |
| Technical debt work | — | Included | Included |
| Named engineer | — | ✓ + backup | ✓ team |
| Dedicated QA | — | — | ✓ |
| Dedicated PM | — | — | ✓ |
| Architecture planning | — | — | ✓ |
| Monthly report | ✓ | ✓ | ✓ |
| Quarterly review | — | ✓ | ✓ |
| SLA credits | — | — | ✓ |
No lock-in
30 days' notice, any plan. Full handover of code, documentation and access, at no extra cost.
Emergency support without a contract
Something's on fire and you're not a client? We'll help on an hourly basis. Talk about plans afterwards.
Change plans any month
Up or down, no penalty.
Unused hours roll over
For one month, then they expire. We'd rather you spent them on the system than banked them for a year.
Not sure which plan fits, or whether your system needs support or a rebuild? Book a call, bring your repository access, and we'll give you an initial read on the spot.
Kamil · Founder
Frequently Asked
Questions
Can't find the answer to your question? Just send me an email:
Ask me a questionWhat kind of software do you support?
Custom web applications, mobile apps and internal business systems — ours and other people's. We also take on WordPress and PHP systems where the goal is stabilising them. What we don't do is support software whose stack we don't know well; we'll tell you that in the first call rather than learn on your budget.
Will you take over a system somebody else built?
Yes, routinely. It starts with an audit, because we won't commit to response times on code we haven't read. Missing documentation is normal and not a reason to refuse — reconstructing how a system works is part of the job.
What does the audit cost?
It depends on size, and it takes 3–10 days. You get a written report on the system's condition, ranked risks and a recommendation. It's yours to keep regardless of what you decide — including if you take it to a different vendor. If you sign a plan, we credit it against your first month.
What if you tell us it needs rebuilding?
Then that's what we'll tell you, with the reasoning and a rough cost, and you decide. Sometimes the answer is a staged rebuild while we keep the current system alive in parallel. We'd rather lose a support contract than take monthly payments to maintain something that can't be maintained.
How fast do you actually respond?
Critical means the system is down or unusable: 30 minutes to 4 hours depending on plan, 24/7 on Dedicated. High means something important is broken but there's a workaround: same business day. Medium and low get scheduled into the monthly work. All of it is in the agreement, with severity defined so it isn't a matter of opinion.
What counts as critical?
Defined in writing before we start, together, using your business rather than our convenience. For a shop, checkout failing is critical. For an internal system, month-end reporting failing on the 30th is critical and the same failure on the 5th probably isn't. Vague severity definitions are where support relationships go wrong.
Do you need access to our production data?
As little as possible. We work on anonymised or masked data where we can, and we sign a DPA before touching anything real. Access is named, logged and revocable — and we'll tell you exactly who on our side has what.
Can you work alongside our own developers?
Yes, and it's a common arrangement. Your team builds features while we handle monitoring, updates, security and the maintenance nobody has time for. We fit your process, your repository and your review standards rather than imposing ours.
What happens if we want to leave?
30 days' notice on any plan. You get a handover: documentation, credentials, a walkthrough call with whoever takes over, and a written summary of the system's current state and open risks. No exit fee. Everything is in your accounts already, so there's nothing for us to release.
Is there a setup fee?
No, beyond the audit. Onboarding — access, monitoring, environments, documentation — is part of the first month.
Do unused hours carry over?
For one month, then they expire. Support works best as steady attention rather than a bank of hours drawn down during a crisis, but losing a month's budget because a quiet January happened isn't fair either.
What if we only need help once, right now?
We'll help on an hourly basis, no contract. Plenty of these turn into plans afterwards, and plenty don't — both are fine.
Our system is on old technology. Will you still take it?
Often yes. Old isn't the same as unmaintainable, and a stable system on an unfashionable stack is usually cheaper to keep running than to replace. The audit tells us whether that's true in your case — and if the honest answer is that it's a dead end, we'll say when rather than if.