Read before changed
The codebase is audited first. Quoting on code nobody has read is how estimates double halfway through.
Twelve years in the language most of the web still runs on.
WordPress, WooCommerce, Laravel, Magento and a great deal of custom business software are all PHP underneath. I work at that level – building, upgrading, securing and rescuing applications whatever is or is not sitting on top.
PHP runs a large share of the web, and not only through WordPress. Most of the e-commerce platforms in common use are PHP. So are a great many custom business applications, written by in-house teams and agencies over the last two decades and still doing their job.
The language itself has changed substantially. Modern PHP has proper type declarations, attributes, enums, readonly properties, match expressions and a performance profile unrecognisable from version 5. Code written today looks and behaves more like a typed language than the PHP most people remember complaining about.
The gap that creates is the problem I am usually called about. A business runs an application written in 2013, on a PHP version that stopped receiving security patches years ago, that fails to run on anything current. The host eventually forces an upgrade, or a security audit finds something, and suddenly the application has to be modernised by someone.
That work is not glamorous and it is not difficult so much as methodical: finding every incompatibility, understanding code nobody documented, fixing patterns that were acceptable then and are vulnerabilities now, and doing it without breaking the thing the business runs on.
Applications built in modern PHP, with a framework where one helps and without where it would only add weight.
Software sized to the problem instead of the tooling.
Moving applications onto supported PHP versions, finding and fixing every incompatibility methodically.
Security support, and hosting that is not pinned to a release from years ago.
Taking on undocumented code nobody else will quote for, and making it maintainable again.
Software your business depends on stops being one person’s private knowledge.
Reviewing for injection, input handling, session management, file uploads and dependency vulnerabilities.
Known vulnerability classes closed in software handling real data.
Profiling to find the slow query, the N+1, the missing index or the operation that should have been queued.
Faster applications from fixing causes rather than adding caching over the top.
Payment gateways, CRMs, ERPs, messaging and logistics, with retries, logging and error handling.
Systems that stay in step, with failures visible in a log.
The code usually matters to someone, whatever state it is in.
The codebase is audited first. Quoting on code nobody has read is how estimates double halfway through.
Findings ordered by exploitability and what they expose, so urgent items can be dealt with before feature work.
Type declarations and current language features on new code, without a pointless rewrite of what already works.
If the code exists only on a server, getting it into Git is usually the first genuinely useful step.
Working software gets improved in place. A rewrite has to earn itself, and most do not.
How it works, what is fragile, how to deploy it – written while it is being learned.
Usually someone with code and no one to look at it.
Stuck on an unsupported version, with a host starting to insist.
Software that runs the business and nobody who understands it.
An audit or an incident that named something in the code.
Software that fits the business less well every year.
An application or API, built without hiring a team.
A codebase your team will not take on.
A great deal of Indian business software is PHP, written over the last fifteen years by in-house teams and agencies. Much of it still runs, and much of it has outlived the people who built it – which is how a working application ends up with nobody willing to touch it.
Indian integration work is usually part of the job: Razorpay, PayU and Cashfree rather than assuming Stripe, the SMS and WhatsApp providers used here, GST-compliant invoice generation, and identity verification services where a workflow calls for them.
I work with businesses across Bangalore and India, and with clients in the UK, USA, Canada, the UAE and Singapore.
Codebases most developers decline to quote for.
Razorpay, PayU, local SMS and WhatsApp providers.
Compliant document generation where it is needed.
India, the UK, USA, Canada, the UAE and Singapore.
Serving Chennai, Bangalore, India, Canada, UK, USA, Dubai, Singapore.
Generally somewhere central and unfashionable.
Typically needs: Student, fee and examination systems built in-house years ago.
How I help: Version upgrades, security review of student data handling, and feature work that matches how the institution runs now.
Typically needs: Patient and appointment systems in clinics and diagnostic centres.
How I help: Access control tightened, data handling reviewed, and changes made without disturbing daily operations.
Typically needs: Inventory, billing and dispatch predating current accounting software.
How I help: Integration with existing systems, GST-compliant invoicing, and performance work as data has grown.
Typically needs: Custom stores or heavily modified platforms nobody wants to touch.
How I help: Modification audit, safe upgrade paths, and an honest view of rebuilding on a maintained platform.
Typically needs: Loan, insurance and agent systems with regulatory exposure.
How I help: Security audit, audit logging where it is missing, and careful methodical feature work.
Typically needs: Consignment and dispatch systems built for older operations.
How I help: Workflow changes, API layers so newer systems can integrate, and database work at current volumes.
Reading first. On unfamiliar code that is most of the job.
I read the codebase: PHP version, structure, framework if any, database schema, where the business logic lives, what is duplicated, and what looks unsafe.
You get: A written audit with security findings ranked, and a realistic view of what can be improved in place.
Why it matters: Legacy code reliably contains surprises, and finding them before quoting is the point of the exercise.
We agree scope: what gets fixed, what gets built, whether a PHP upgrade is urgent, and whether any of it justifies a rewrite.
You get: An agreed plan and a fixed quote, with security work separated by urgency.
Why it matters: Mixing urgent security items into a feature quote hides which parts cannot wait.
Before changing anything: code into version control if needed, a staging environment created, and a backup and restore proven rather than assumed.
You get: Version control, staging and a tested restore.
Why it matters: A surprising number of these applications exist only on one server, with no history and no verified backup.
The work in small deployable pieces, in the codebase’s own idiom, with modern practice applied to new code rather than imposed on all of it.
You get: Working changes deployed in increments you can see.
Why it matters: Long-running branches against legacy code diverge from production and turn small jobs into large ones.
Testing the affected workflows properly, with automated tests added around anything critical being changed, and performance measured where that is the concern.
You get: Verified changes, and tests where they will earn their keep.
Why it matters: Without an existing test suite, deliberate manual testing is the only honest substitute.
Deployment, then documentation – architecture, deployment steps, fragile areas and integration points.
You get: Live changes and documentation that did not exist before.
Why it matters: The documentation is what makes the next change affordable, which is often the real deliverable.
The language, the things built on it, and the tools around it.
Scoped from the audit, with security separated by urgency.
Most custom PHP work sits behind a login, where search visibility is irrelevant and the concern is the reverse: making sure nothing internal is reachable or indexable.
Where an application has public pages, they get the same treatment as any public site – server-rendered markup, clean URLs and proper metadata.
For a codebase, readability means the next developer – or any tool assisting them – can understand it without reconstructing intent from behaviour. Consistent structure, typed signatures and documentation are what make that possible.
The practical reasons, rather than the adjectives.
Laravel, CodeIgniter, WordPress, a store platform, or no framework at all. The language is the constant, and I am not going to insist your code be rewritten into my preference.
Most developers decline it because estimating on unfamiliar code feels risky. The audit removes that risk for both of us, which is why it comes first.
Working software usually gets improved in place. A rewrite is the expensive, risky option and it should have to justify itself against doing the boring thing well.
The audit checks for known vulnerability classes as a matter of course and ranks what it finds, so the urgent items can be acted on separately from anything else.