PHP support

PHP application maintenance for code someone else wrote

Your developer has moved on and the application still has to run. We take over existing PHP codebases, learn them properly, keep them patched and monitored, and work through the backlog at a steady pace.

  • Takeovers of inherited code
  • A team, not one freelancer
  • Documentation written as we go
What is included
  • Audit of code and server
  • Documentation from scratch
  • Security and dependency updates
  • Bug backlog
  • Monitoring and logs
  • Small features
Get a free quote Reply within one business day. NDA on request.
The problem

How applications end up orphaned

Few people come looking for PHP maintenance when things are calm. They come because the freelancer who built the system has stopped replying, the agency closed, the in-house developer resigned, or a routine server update took the site down and nobody knew how to bring it back. The application matters to the business. The knowledge of how it works walked out of the door.

Taking over code written by someone else is a discipline of its own. Before we promise fixes we find out what is really there: where the code lives, how it is deployed, what it depends on and where it is fragile. Then we put the basics in place (version control, backups, monitoring, documentation) and start on the list of bugs and small improvements you have been carrying around. Our general maintenance and support page covers plans across all technologies. This one is about PHP specifically.

  • The only developer is gone

    One person built the system, deployed it and held every password. Now a small change request has nowhere to go, and you are not sure what you would hand to a replacement.

  • Nobody knows what is on the server

    Files have been edited live for years. There may or may not be a repository, and if there is, it does not match what is running. Backups are assumed, not verified.

  • Errors are reported by customers

    The first sign of a problem is a phone call. There is no monitoring, the error log is either switched off or enormous, and failed scheduled jobs go unnoticed for weeks.

  • Every fix is a fresh negotiation

    Each small bug means finding a freelancer, explaining the system from the beginning and hoping the fix does not break something else. The backlog quietly grows.

What we do

What maintenance covers

Maintenance is a fixed routine plus a flexible allowance of development time. The routine keeps the application safe, and the allowance moves your backlog.

Audit of code and server

A written review of structure, PHP version, dependencies, database, security exposure and deployment, with findings ranked by risk and an honest view of what can wait.

Documentation from scratch

A README, an architecture sketch, a list of scheduled jobs and integrations, and a runbook for deployment and recovery, written as we learn the system.

Security and dependency updates

Composer packages, PHP patch releases and server software updated on a schedule, tested on staging first, with known-vulnerability checks run against the lock file.

Bug backlog

Issues logged in a tracker, reproduced, prioritized with you and fixed with a regression test where one is practical, so the same bug does not return.

Monitoring and logs

Uptime checks, error tracking with alerts, log rotation, disk and certificate expiry warnings, and watched cron jobs that tell us when they fail to run.

Small features

A new report, an extra field, a changed email, an added export. Modest improvements handled inside the monthly allowance without a separate project for each.

Typical projects

Situations we step into

01

Takeover from a departed developer

We gather access, recover or create the repository, document the system and become the team you call, usually starting with the fixes that have waited longest.

02

Standby support for an in-house team

Your developer stays in charge and we cover holidays, overflow and specialist problems, with enough knowledge of the codebase to step in without a long briefing.

03

Stabilizing a fragile application

Frequent crashes, slow pages or a recent hack. We find the causes, patch the holes, add monitoring and bring the system to a state where routine upkeep is enough.

04

Care for a business-critical legacy tool

An old but essential system that will not be rebuilt soon, kept secure and running with minimal change, plus a plan for the day it must be upgraded.

In depth

Taking over a PHP codebase

Access comes first, code second

The first job is finding everything. Domain registrar, DNS, hosting account, server logins, database, repository, email service, payment gateway, SMS provider, and any API keys baked into config files. We list them, confirm that you and not a former contractor own each account, and rotate the passwords and keys the previous developer knew. Then we take a full backup and restore it somewhere else. A backup that has never been restored is a hope, not a backup.

Getting the code under control

If there is no repository, we create one from what is running in production, since that is the only version that counts. If a repository exists, we compare it with the server, and it often differs because of hot fixes made directly on the live site. From then on nothing is edited on the server. We build a staging copy and a scripted deployment so a release is one command and can be reversed. Passwords and keys found in the code are moved into environment configuration.

What the audit looks at

We read the code the way a buyer inspects a house. Which PHP version does it need, and is that version still supported? Which Composer packages or bundled libraries have known vulnerabilities? Has anyone edited files inside the vendor folder by hand? Are errors printed to visitors or written to a log? Are queries parameterized? Can an uploaded file be executed? Where are the single points of failure, such as a cron job that emails invoices with no alert when it stops? The report sorts findings into fix now, fix soon and live with it. Not everything ugly is urgent, and we will not turn an audit into a sales pitch for a rewrite. If the PHP version is out of support, we scope that separately as a PHP migration and upgrade.

The monthly rhythm

Once stable, the work settles into a pattern. Security updates are applied to staging, checked and released. Logs and monitoring alerts are read and acted on, which is different from merely collecting them. Backlog items are picked up in priority order within the agreed hours, and you get a short report: what was updated, what was fixed, what we noticed, what we recommend next. Anything urgent, like a site down or a payment failure, jumps the queue.

Handover hygiene works both ways

We run every maintained application as if we might hand it over tomorrow. Documentation stays current, credentials live in a shared vault you control, and the repository sits in your organization. If you later hire in-house or move to another supplier, they receive a system in far better order than the one we inherited. That is the standard we wish every previous developer had kept.

Process

Onboarding, then a steady rhythm

  1. 1

    Access and backup

    We collect logins, confirm account ownership, take a full backup and prove it restores. Credentials known to former developers are changed.

  2. 2

    Audit and report

    Code, server and database are reviewed, and you receive a ranked list of risks with our recommendation for the first month.

  3. 3

    Repository, staging, monitoring

    Version control, a staging site, scripted deployment, monitoring and documentation are put in place before feature work begins.

  4. 4

    Fix what is dangerous

    Urgent security gaps and the most damaging bugs are fixed first, with tests added around the areas we touch.

  5. 5

    Ongoing care

    Scheduled updates, monitoring, backlog work and a monthly summary continue for as long as you want them, on a plan sized to your application.

Deliverables

What changes for you

  • A named team that knows your application
  • Documentation and a runbook that did not exist before
  • Tested backups and a working staging site
  • Security updates applied on a schedule
  • A backlog that shrinks instead of growing
FAQ

Support questions answered plainly

Our PHP application was built by someone else. Can you support it?
Yes, that is the purpose of this service. We begin with an audit so that we know the codebase before we commit to supporting it, and so that you get a clear picture of its condition whatever you decide next.
What if there is no documentation and no repository?
Then creating both is our first task. We build the repository from the live server, document the system as we explore it and record how to deploy and restore it. Missing documentation is the usual situation and does not prevent a takeover.
Who do we contact when something stops working?
Your project manager and the support channel named in your agreement, which can be email, Slack or another tool you already use. Response times are set in your support agreement and depend on the plan, with site-down and payment problems treated as the highest priority. Monitoring often alerts us before you notice anything. New inquiries get a reply within one business day.
What does a PHP maintenance plan include?
A routine part and a flexible part. The routine covers updates, backup checks, monitoring and a monthly report. The flexible part is an allowance of developer hours for bug fixes and small features. We size both after the audit, based on how the application is built and used.
Can you also speed the application up?
Yes. Slow pages usually trace to missing database indexes, queries inside loops, no caching or an outdated PHP version. Light tuning fits inside maintenance hours, and deeper work is handled as a performance optimization project with before and after measurements.
Would hiring a dedicated developer be better than a plan?
It depends on volume. A plan suits applications needing a few hours to a few days each month. If you have continuous work, you can hire a PHP developer part time or full time, with a project manager on our side and a replacement if the fit is wrong.
Are we locked in?
No. The repository, servers, documentation and credentials sit in your accounts from the start of the engagement. You can end the agreement under its notice terms and take everything to an in-house hire or another supplier, and we will walk your next team through it.
Related

From the blog

All articles
Start a project

Inherited a PHP application with no one to look after it?

Tell us what the application does and what you know about how it is hosted. We reply within one business day and can start with an audit before you commit to a plan.

  • Free consultation and quote
  • NDA on request
  • You own the source code
  • Reply within one business day
Add budget and timeline optional, helps us quote faster

This form is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.