Audit before anything
The codebase is read before it is changed. Quoting on an application nobody has looked at is how estimates get doubled halfway.
Looking after the applications everyone else has stopped quoting for.
A great many working Indian business applications were built on CodeIgniter and are still running. I maintain them, extend them, upgrade them where there is a path, and migrate them to Laravel in stages when that is the better spend.
CodeIgniter was for years the pragmatic choice for PHP applications in India: small, fast, undemanding about hosting, and simple enough that a competent developer could be productive in a week. An enormous amount of working business software got built on it – ERPs, school systems, booking platforms, internal tools – and a lot of it is still in daily use.
The framework has not stood still; version 4 is a substantial modernisation. But the industry’s attention moved to Laravel, and with it the developers. The practical result is that businesses running perfectly functional applications find nobody willing to quote for a change, which is a hiring problem rather than a technical one.
The applications themselves are usually in a predictable state. Version 3 or earlier, an old PHP version underneath, no automated tests, thin documentation, and a few places where the original developer solved something urgently rather than well. None of that stops it working. All of it makes change slower and riskier than it should be.
So the choice is the familiar one, and both answers are legitimate. Maintain and extend what you have, which is cheaper and entirely reasonable when the application does its job. Or migrate to Laravel in stages, which costs more now and makes the next five years easier to staff.
Ongoing care for an application nobody else will touch – fixes, small changes and keeping it running.
Software your business depends on stops being a single point of failure.
Extending an existing application in its own idiom rather than bolting on something that sits awkwardly beside it.
The system keeps up with the business without a rebuild.
Auditing for SQL injection, weak input handling, session problems and outdated dependencies, then fixing them.
Known vulnerability classes closed in software that is handling real data.
Moving onto a supported PHP version, and to CodeIgniter 4 where the codebase makes that sensible.
Security support and hosting that has not been frozen in 2016.
Moving functionality across in phases, with both systems running until the last piece is done.
A modern codebase without the risk of a big-bang rewrite.
Writing down how an undocumented application actually works, for whoever comes next.
You stop being dependent on whoever happens to remember.
Careful, because this software is usually load-bearing.
The codebase is read before it is changed. Quoting on an application nobody has looked at is how estimates get doubled halfway.
Older applications often carry vulnerability classes that were normal practice when written. Those get flagged in the first week, not the last.
Plenty of these applications live only on the server. Getting the code into Git is often the first useful thing anyone can do.
Rewrites of working software fail often and expensively. Functionality moves across in pieces, with the old system running throughout.
How it works, what is fragile and where the surprises are – documented while it is being learned rather than from memory later.
Maintaining is cheaper now; migrating is easier to staff later. Both costs, both stated, and the decision is yours.
Almost always the same situation.
A working application, no documentation, and nobody who knows how it fits together.
Stuck on an unsupported PHP version because upgrading breaks something nobody can diagnose.
A business that has changed shape while its software has not.
An older application handling customer or financial data, never audited.
Wanting to move to Laravel without stopping operations to do it.
A codebase your team will not take on, for a client you do not want to lose.
This framework had a long run with Indian software companies and agencies, which is why so many business applications here run on it. The developers who built them largely moved to Laravel, and the applications did not move with them.
The result is a specific and slightly absurd situation: working software that a business depends on daily, which nobody will quote to change. Not because it is difficult, but because it is unfashionable and estimating on an unfamiliar legacy codebase feels risky.
I will look at it. I work with businesses across Bangalore and India, and with clients in the UK, USA, Canada, the UAE and Singapore, and the first deliverable is usually an audit telling you what you actually have.
Work most developers now decline to estimate.
An honest account of the codebase before any commitment.
Older applications checked for known vulnerability classes.
India, the UK, USA, Canada, the UAE and Singapore.
Serving Chennai, Bangalore, India, Canada, UK, USA, Dubai, Singapore.
Usually something central and unglamorous.
Typically needs: Student records, attendance, fees and results built years ago and still run every day.
How I help: Feature work in the existing idiom, gateway updates for fee collection, and security review of student data handling.
Typically needs: Patient records and appointment systems in small clinics and diagnostic centres.
How I help: Access control reviewed, data handling tightened, and features added without disturbing daily operations.
Typically needs: Inventory, billing and dispatch systems predating the current accounting software.
How I help: Integration with current systems, GST-compliant invoicing, and staged modernisation.
Typically needs: Consignment tracking and dispatch built for how the business worked a decade ago.
How I help: Workflow changes to match current operations, plus API work so newer systems can talk to it.
Typically needs: Loan, insurance and agent systems with real regulatory exposure.
How I help: Security audit, audit logging where it is missing, and careful feature work.
Typically needs: Job tracking, timesheets and billing tools built in-house long ago.
How I help: Maintenance and extension, or a staged move to Laravel where the business has outgrown it.
Reading comes before writing, which on legacy code is most of the job.
I read the codebase: framework and PHP versions, structure, database schema, where the business logic actually lives, what is duplicated, and what looks fragile or unsafe.
You get: A written audit with the security findings ranked, and an honest maintain-versus-migrate comparison.
Why it matters: Nobody can quote sensibly on code they have not read, and legacy applications reliably contain surprises.
We agree the direction and scope – what gets fixed, what gets built, whether a PHP or framework upgrade is realistic, and whether migration should start.
You get: An agreed plan and a fixed quote, with security work separated out by urgency.
Why it matters: Security findings often need acting on faster than feature work, and mixing them hides that.
Before changing anything: code into version control if it is not already, a staging copy created, and a backup and restore proven to work.
You get: A safety net – version control, staging and a tested restore.
Why it matters: A great many of these applications exist only on one server with no history and no verified backup.
The work itself, in the application’s own idiom, in small deployable pieces rather than long branches that diverge from production.
You get: Working changes, deployed in increments you can see.
Why it matters: Long-running branches on legacy code are how a two-week job becomes a three-month one.
Testing the whole affected workflow manually, since there are rarely automated tests, with new tests added around anything critical that is being changed.
You get: Verified changes, and the beginnings of a test suite where it matters most.
Why it matters: Without tests, the only way to know something still works is to exercise it properly.
Deployment, then documentation – how the application is structured, how to deploy it, what is fragile and where the surprises are.
You get: Live changes and written documentation that did not exist before.
Why it matters: The documentation is often worth more than the feature, because it is what makes the next change affordable.
The framework as it is found, and where it usually goes.
Scoped from the audit, with security separated by urgency.
These applications are usually internal, so search visibility is beside the point. The risk runs the other way: older systems sometimes expose pages that were never meant to be public, and a guessable report URL with no authorisation check can put real data into a search index.
Where part of the application is genuinely public – a listing, a directory, a portal front page – it gets the same treatment any public page does.
For a legacy application the readability that matters is human. Documentation, consistent naming and a predictable structure are what let the next developer – or any tool helping them – understand what is there without reverse-engineering it from behaviour.
The practical reasons, rather than the adjectives.
Most developers decline legacy work because estimating on an unfamiliar codebase feels risky. The audit exists precisely to remove that risk for both of us.
Rewriting working software in one go fails often and expensively. Functionality moves in stages with the old system running, which is slower and far more likely to succeed.
Applications of this age often carry vulnerability classes that were normal practice when written. Those are found and ranked in the first week, not mentioned at the end.
Written down as the code is learned. On a legacy application that is frequently worth more than the feature you asked for, because it is what makes every later change affordable.