Free checklist Book a call →
Home/ Hire talent/ PHP Developers

Hire talent · Back end

Hire PHP developers

Add a PHP engineer to your team to read, document and safely change the application your business already depends on. For codebases with no tests, no documentation and nobody left who wrote them.

Book a call → Get the CTO checklist

What they do

What a PHP Developer from infoloop actually builds.

Laravel, Symfony and in-house frameworks

A great deal of the PHP that runs a business belongs to no framework at all, or to one a previous team wrote themselves and never wrote down. We work in Laravel and Symfony, and just as readily in code that has neither, learning the bespoke router and its habits before adding anything to it.

Legacy code brought under static analysis

PHPStan or Psalm introduced at a level the existing code can actually pass, then raised a step at a time. Undeclared types, unreachable branches and null paths turned into a list you can work through rather than surprises found by a customer. PSR-12 and Composer autoloading applied so files sit where a new developer expects to find them.

APIs and integrations

The connections an inherited codebase already carries: a payment gateway, a CRM, a courier, an internal service someone wired in and left. We find every call site, log what goes out and what comes back, and put failure handling around the ones written on the assumption that the other end always answers.

Database and performance work

A slow page traced back to the code that made it slow, which in inherited PHP is usually a query sitting inside a loop nobody noticed. We measure before we touch anything, add the index or rewrite the join on evidence, and write down what we found so your own team recognises the same shape next time.

Admin panels and internal tools

The screens staff use to run orders, stock, approvals and reporting are often the oldest part of a PHP estate and the least explained. We map which screen writes to which table before altering any of it, then rebuild the parts that genuinely hurt while leaving the routines people have built their day around.

Getting current behaviour under test

Most of this code has never had a test written against it. We start by pinning down what it does today, including the parts that are arguably wrong, so that any change which alters the output announces itself straight away. Releases then move off manual file copying and onto a scripted step your own team can run and reverse.

How it runs

Plan. Build. Run.

01

A 30 minute call

Show us the repository, or describe the thing if nobody can open it. We want to know who wrote it, who has since left, what breaks most often and which corner everyone avoids. You finish the call knowing which parts we would read first and which we would deliberately not disturb.

02

Fixed scope and price

Pricing unread PHP is guessing, so the scope is written against what can actually be seen: the entry points, the dependency file, the age and spread of the code. It sets out what is included, in what order, over what period and at what price, and it names the areas that could move the number once opened. Anything that does move gets repriced in front of you rather than quietly absorbed and delivered late.

03

Build in your repository

Changes arrive as small branches, each with a note saying which existing behaviour it preserves. Where there is no test suite yet, that note is what makes review possible at all. Your developers see each one as it lands and can stop a direction after a single commit instead of at the end.

04

Launch, then run

Releases go out in pieces, each one watched against the specific pages and routines it touched. When the work finishes you get the codebase map and a recorded walkthrough for whoever inherits it after you. If the last handover never happened, this one does.

Why infoloop

We do not hand over and leave.

  • We stay with code we did not writeThe retainer covers monitoring, fixes against agreed response targets, security and dependency updates and a written monthly report. Committing to that on somebody else's undocumented codebase is the harder version of the offer, and it is the version we make.
  • Nothing we leave depends on usWe do not add a framework of our own on top of the one you already inherited. What stays behind is ordinary PHP, Composer packages anyone can look up, and configuration your developers can read on their first morning.
  • Written for whoever comes nextThe test we care about is whether one of your own engineers can make the following change without phoning us. So the trace documents, the named traps and the reasoning all get handed over, and we review our work with the person who will be keeping it.
  • Priced after reading, not beforeNo open-ended hourly arrangement on a codebase whose true size nobody knows yet. The block of work has a stated boundary and a stated cost, and when something we open changes that, you hear it as it happens rather than at the invoice.
  • Not a PHP-only shopWe have shipped 50 or more products across 6 countries and hold a 99.9% uptime record on what we run. An inherited PHP application almost always has a front end, a storefront or a reporting layer attached to it, and those sit with colleagues at the same desk rather than with a second supplier you would have to brief separately.

What you get

Every engagement includes these, in writing, before work starts.

  • A written map of the codebase: entry points, request paths, and which code owns which table
  • A working application in your repository, with a README that explains how to run it locally
  • Tests pinning the behaviour of the paths we touched, wired into a pipeline that runs on every push
  • A static analysis configuration your team can keep running, at a level the code passes today
  • A note of what we changed, what we deliberately left alone, and the reasoning for each
  • A recorded handover session covering the architecture and the parts that need care

Who this is for

Three situations where this is the right call.

A PHP application nobody wants to touch

It has run the business for years, the people who wrote it have gone, and every change now feels like a gamble. You need someone to read it properly, write down how it actually works, and make the next change a safe one to make.

A framework written in-house and abandoned

The application sits on a framework a previous team built themselves. There is no community behind it, no documentation and no upgrade path, and every new developer has to learn it from the source before being useful. You need someone willing to read it rather than propose replacing it.

A change to make and nothing covering it

Something has to move — a tax rule, a price band, a new integration — and the area has no test, no note explaining it and no environment to try it in. You need current behaviour pinned down before anybody edits a line of it.

Questions

What buyers ask us first.

How much does hiring a PHP developer through infoloop cost?
There is no hourly rate here. We agree a written scope with a timeline and a single price attached, and that price holds. What moves it is how readable the codebase turns out to be: how many entry points the application has, whether Composer manages the dependencies or a vendor folder was assembled by hand, how much logic is hiding in template files, and how much of it anybody in the business can still explain. A tidy application with an owner is a small number. An undocumented one carrying three generations of routing is not. Describe what it does and where it came from and you will get a range on the call itself, not after a paid discovery phase.
What happens once the work is finished?
That is your decision. Take everything and run it yourself and you leave with the codebase map, the recorded walkthrough and access to every account we opened. Or keep us on the managed retainer: monitoring, fixes against agreed response targets, security and dependency updates, further work as you want it, and a written monthly report. The reason we offer the second option is specific to this kind of code. An inherited PHP application that receives attention for a while and then none at all slides back into being the thing nobody will touch, and the documentation we wrote goes stale alongside it.
Can your developer work inside our existing team and codebase?
That is how the engagement is set up to run. We take repository access and work on branches through whatever review your team already runs, in your tickets and your standups. On inherited code we deliberately match what is already there — the naming, the directory layout, the way errors are currently handled — even where none of it is how we would have begun. Where a pattern is actively costing you, we say so, put a price on changing it, and wait for your decision. Nothing gets rewritten quietly because we happened to prefer it another way. If you would rather we worked at arm's length and handed the result over at the end, that works too.
Which PHP versions and frameworks do you work with?
Current supported PHP, and Laravel and Symfony where they are in play. Equally important for this page: plain procedural PHP, and in-house frameworks with no name and no manual, which is what a great many long-lived business applications are genuinely built on. If your application is on a release that no longer receives security fixes we will say what that means for everything else on the list, because it changes the cost of each other item. And if PHP is not where this thing should live any more, you will hear that on the first call rather than after we have taken the work.
The people who wrote this application have gone. Where do you start?
By reading it, and by writing down what we read. We pick the routes that carry the most business — checkout, invoicing, dispatch, whatever yours happen to be — and follow each one from end to end: the entry point, the includes it pulls in, the functions it reaches, the tables it writes, the mail or file it produces on the way out. That trace becomes a document you keep. Only then do we put tests around the behaviour as it stands today, including the parts that look wrong, because the first requirement is being able to tell whether a change altered anything. Editing code in an application nobody understands is how a small fix turns into an outage.
How quickly can someone start, and what do you need from us?
Days rather than months, once scope and price are signed off. That is the argument for this route over opening a vacancy. What we need first is access: the repository, a database copy with realistically shaped data, somewhere that is not production to run it, and logins for the outside services the application calls. After that, one person who can answer "is it supposed to do that?" when we find something odd, which in code this old and this undocumented is a question that comes up early. If nobody left in the business can answer that question, tell us early — it does not stop the work, but it changes how we scope it.

Related

You might also need.

Laravel Developers

PHP applications on Laravel: APIs, queues, admin panels and the tests that keep them safe.

See more →

Node.js Developers

Services, APIs and integrations on Node, built to be monitored and rolled back.

See more →

MongoDB Developers

Schema design, indexing and query work for document databases under real load.

See more →

Tell us what the application has to do. Book a 30 minute call

Send the repository, or simply describe what the thing does and who used to look after it. You will hear which parts we would read first, what we would fix, what we would leave untouched and what that block of work costs. A scope, on the call, not a document that turns up next week.

Book a call → Get the CTO checklist
Book a call Checklist