Application Support & Maintenance
Keep production healthy and keep the product moving. Managed support with defined response times — for software we built, and for software we didn't.

Software does not finish. It needs patching, monitoring, dependency upgrades, and a steady stream of small improvements — none of which is glamorous, all of which is what keeps a system from quietly rotting.
We take on applications we built and applications we inherited. Inherited systems start with a paid audit, because committing to response times on a codebase we haven't read would be a promise we couldn't keep.
What we do
What support covers
Six areas covered under every tier. The difference between tiers is response time and reserved capacity, not which of these you get.
01Production supportIncident response with agreed severity levels and response times, plus a written post-incident review.
Incident response with agreed severity levels, response times, and a written post-incident review for anything significant. The review matters more than the response time: an incident that recurs monthly because nobody had time to find the root cause is far more expensive than the hours spent on each individual fix. We track recurrence explicitly and treat a repeat incident as a defect in our own process.
- Severity definitions agreed per system
- Escalation paths and on-call rota
- Written post-incident reviews
- Recurrence tracking and root-cause work
02Bug fixingTriage, reproduction, fix, and regression test — tracked where you can see it.
Triage, reproduction, fix, and regression test — tracked in a system you can see rather than reported to you after the fact. Reproduction is where most of the time goes and where most vendors cut corners; a fix applied without a reliable reproduction is a guess, and guesses come back. We write a failing test first wherever the codebase allows it.
- Reproduction before fix, wherever possible
- Regression test for each resolved defect
- Shared tracker with real status
- Monthly summary of what was fixed and why
03Security patchingDependency monitoring, CVE tracking, and scheduled patch cycles before something becomes urgent.
Dependency monitoring, CVE tracking, and scheduled patch cycles so upgrades happen on a calendar rather than in a panic. The risk in a mature codebase is rarely a dramatic zero-day; it is the accumulation of thirty minor versions behind, until the upgrade path itself becomes a project. Steady small patches prevent that compounding.
- Automated dependency and CVE monitoring
- Scheduled patch windows
- Severity-based emergency patching
- Upgrade path maintained, not deferred
04Performance optimisationProfiling, query tuning, caching, and front-end performance work driven by real usage data.
Profiling, query tuning, caching, and front-end work driven by real usage data rather than intuition. We measure first and publish the numbers, because performance work without a baseline is indistinguishable from performance theatre. Most systems have two or three dominant bottlenecks and a long tail that is not worth touching.
- Baseline measurement before any change
- Database query and index analysis
- Caching strategy at the right layer
- Front-end load and interaction metrics
05Feature enhancementA reserved share of each month for new work, so the product keeps improving instead of only being defended.
A reserved share of each month for new work, so the product keeps improving instead of only being defended. Support arrangements that cover incidents alone tend to produce systems that are stable and slowly becoming irrelevant. Reserved capacity keeps small improvements flowing without needing a separate project each time.
- Agreed monthly capacity for new work
- Backlog prioritised with you each cycle
- Same delivery standards as project work
- Rollover rules agreed in advance
06Monitoring & observabilityAlerting, dashboards, and log aggregation set up so problems surface before your users report them.
Alerting, dashboards, and log aggregation configured so problems surface before your users report them. The goal is a small number of alerts that always mean something — an alert channel everyone has learned to ignore is worse than no alerting, because it creates the appearance of coverage.
- Uptime, latency, and error-rate alerting
- Structured logging and log aggregation
- Dashboards for technical and business metrics
- Alert tuning to eliminate noise
Who it’s for
Who this is for
- Companies running software with no dedicated engineering team behind it.
- Teams whose original developers or agency have moved on.
- Businesses needing defined response times for a system operations depends on.
- Product owners who want small improvements shipped continuously, not batched into annual projects.
Process
How onboarding works
- 01
Audit
Paid, fixed-scope review of the codebase, infrastructure, dependencies, and known issues. Two weeks typically.
- 02
Stabilise
Fix what the audit flagged as urgent, get monitoring in place, and document what was missing.
- 03
Transition
Runbooks, access, escalation paths, and a rehearsal of the incident process before we're formally on the hook.
- 04
Steady state
Ongoing support under the agreed tier, with a monthly report covering incidents, patches, and shipped work.
Support tiers
Response times are commitments, not aspirations. Pick the tier that matches what the system actually costs you when it's down.
Essential
Business-hours coverage, next-business-day response, monthly patching, and a monthly report.
Standard
Extended-hours coverage, four-hour response on critical issues, proactive monitoring, and reserved enhancement capacity.
Critical
24/7 on-call, one-hour response on critical issues, a named lead engineer, and quarterly architecture review.
Technologies we support
Chosen per project against your constraints — not a list of everything anyone here has ever touched.
- Node.js
- .NET
- .NET Core
- C#
- Python
- Java
- Go
- PHP
- Ruby
- Express
- NestJS
- Django
- FastAPI
- Spring Boot
- React
- Next.js
- Angular
- Vue.js
- TypeScript
- JavaScript
- HTML5
- CSS3
- Tailwind CSS
- Redux
- SASS
- React Native
- Flutter
- Swift
- Objective-C
- Kotlin
- Java (Android)
- iOS
- Android
- Expo
- AWS
- Microsoft Azure
- Google Cloud
- Vercel
- Cloudflare
- DigitalOcean
- PostgreSQL
- MySQL
- MongoDB
- Redis
- Elasticsearch
- DynamoDB
- Snowflake
- BigQuery
- Kafka
- Airflow
- dbt
- OpenAI
- Anthropic Claude
- LangChain
- PyTorch
- TensorFlow
- Hugging Face
- pgvector
- Pinecone
- scikit-learn
- Docker
- Kubernetes
- Terraform
- GitHub Actions
- GitLab CI
- ArgoCD
- Prometheus
- Grafana
- Datadog
- Sentry
- Salesforce
- Apex
- Lightning
- Odoo
- NetSuite
- SuiteScript
- SAP
- Microsoft Dynamics 365
- Power Platform
- Zoho
- Shopify
- Stripe
- Contentful
- Auth0
- Twilio
- SendGrid
- HubSpot
FAQ
Common questions
If something here isn't answered, ask on a call — we'd rather tell you plainly than have you guess.
Will you support an application you didn't build?
Yes — that's a large part of this service. It starts with a paid audit so we know what we're committing to before we commit to it.
What counts as a critical incident?
Defined per engagement, but typically: production down, data loss or corruption, a security breach, or a core business workflow blocked with no workaround.
Can support include new features?
Yes. Standard and Critical tiers reserve capacity each month for enhancement work, so the product keeps moving rather than only being maintained.
Tell us what you’re working on
We reply within one business day, and we’ll tell you honestly if we’re not the right fit.
- 1. We read it properly and reply within a business day.
- 2. A 30-minute call to understand the problem.
- 3. A written proposal, or an honest referral elsewhere.