Modernize legacy website
Modern, fast, conversion-tuned — without losing your SEO
- Senior engineers · IST + EST overlap
- NDA on day 1
- 24-hour reply
Tell us what you need fixed
Reply in 24 hours · NDA on day 1 · No spam.
Modernize legacy website — done properly, by senior engineers
Our team will modernize legacy website stacks built on jQuery, older PHP and table layouts one route at a time, so the business keeps running while the code underneath is replaced. Change is slow on these sites because SQL, business rules and HTML share the same template files, plugins are pinned to jQuery versions nobody can upgrade, there is no staging environment, and edits reach production over FTP. Before writing new code, Krapton’s engineers put the existing site under Git, reproduce it locally in Docker and add Playwright smoke tests that record how key pages and forms behave today. An Nginx reverse proxy then sends migrated paths to a new Next.js front end and everything else to the legacy PHP application, with a shared header, footer and session so visitors do not see a seam between old and new pages. The MySQL database usually stays in place at first, exposed through a small API, which turns data migration into a separate decision. Each route moves only when its URL, content and form behavior match the original. You end with a modern codebase, documentation for every step, and a legacy server that can finally be switched off.
What you're seeing
You're on jQuery + PHP + table-based layouts and every change takes a week.
Our approach
We modernise incrementally with the strangler-fig pattern — route by route, with no big-bang launch and no SEO disruption.
Signs it is time for this
- A one-line copy change needs FTP access and someone who remembers which file renders that page.
- Pages break on phones because layouts rely on nested tables and fixed pixel widths.
- Your host warns that the PHP version is out of support, but upgrading breaks the site.
- Plugin conflicts fill the browser console with jQuery errors on nearly every page.
- Nobody can run the site locally, so every fix is tested directly on production.
What we plan around
- Code written for old PHP releases, using APIs such as the original mysql functions that PHP 7 removed.
- Business logic, SQL queries and HTML markup mixed together in the same template files.
- No version control, staging environment or deployment process, so changes cannot be reviewed or reversed.
- Abandoned jQuery plugins pinned to library versions that newer scripts cannot share safely.
- Layouts built from tables, spacer images and inline styles rather than responsive CSS.
Concrete deliverables, no fluff
Every engagement ends with measurable, documented outcomes — no black-box agency reports.
- Design system and high-fidelity Figma
- Pixel-perfect responsive implementation
- 301-mapped migration that preserves SEO equity
- Post-launch CWV + conversion monitoring
What changes after we ship
The old site under control first
Git history, a Dockerized local copy, staging and smoke tests come before any rewrite, so even pages that have not moved yet get code review and a way to roll back.
New pages beside old ones
An Nginx reverse proxy routes each migrated path to the Next.js app while the PHP site serves the rest, with shared navigation and sessions hiding the boundary from visitors.
Security debt paid down along the way
String-built SQL becomes parameterized queries, remaining PHP pages move to a supported runtime, and credentials leave config files in the web root for environment variables or a secrets store.
A date to switch off PHP
Every route has an owner, tests and a cutover checklist, so the legacy server has a real retirement date instead of lingering for years serving a few forgotten pages.
From brief to shipped fix
A transparent, low-risk process — a senior engineer reads your brief personally, and nothing starts until you approve a written plan and price.
01
Diagnose
A senior engineer reviews your brief, reproduces the issue, and pinpoints the real root cause — not the symptom — before any code is touched.
02
Scoped plan & quote
You get a written plan to modernize Legacy Website, a firm timeline, and a fixed quote. Nothing starts until you approve it — no surprise invoices.
03
Ship the fix
We implement on a branch and open a pull request you review, working to your code-review standards on your repo — never a black box.
04
Verify & hand off
We verify on staging and production, share before/after evidence where it applies, and leave you a short hand-off note so the fix sticks.
Situations we handle
A PHP site on shared hosting
A marketing or catalog site deployed by FTP to shared hosting. We move it into containers on modern hosting first, then replace templates route by route with a component-based front end.
A jQuery-heavy internal portal
Staff log in to a portal of jQuery forms and server-rendered tables. Old and new pages share the login session, so screens can move one workflow at a time without retraining everyone.
A directory with years of URLs
Listing and profile pages with query-string URLs that rank and get linked. We keep them resolving through rewrites or redirects to clean paths, verified with a crawl before and after.
Why teams hand this task to Krapton
Senior engineers only
Your brief is read and handled by a senior engineer — no junior hand-off, no sales-rep filter in between.
Root cause, not a patch
We reproduce and fix the underlying cause, then add a guard so the same class of issue does not quietly return.
Your repo, your standards
Every change lands as a pull request you review, on your repository, following your existing review process.
NDA on day one
Confidentiality and IP are covered before we look at a single line of code. All work stays in your accounts.
Fixed quote up front
You approve a written plan and price before work starts. If scope changes, we re-quote in writing — no surprise invoices.
Proof, where it applies
Performance, SEO and reliability work ships with before/after evidence so the result is measurable, not anecdotal.
Three ways to engage
No retainer required. Pick the model that matches the work — pricing for this task starts from $500, with a fixed quote before anything starts.
Per task
Most popular
One clearly-scoped fix at a fixed price. Best when you know exactly what is broken and want it handled end to end.
- Fixed quote up front
- One PR, reviewed by you
- No retainer required
Hourly
Pay only for the hours worked. Best for diagnostics, audits, or exploratory work where the scope is still emerging.
- Weekly timesheets
- Pay for what you use
- No minimum commitment
Per sprint
A focused 1–2 week sprint when the work is bigger than one fix but smaller than a full project.
- 1–2 week blocks
- Clear sprint goal
- Scale up or stop anytime
Industry-standard stack, no proprietary lock-in
Modernize legacy website — your questions, answered
How much does it cost to modernize Legacy Website?
Pricing starts from $500 and depends on the scope we find during the diagnostic. You get a fixed, written quote before any work begins — most engagements like this run 4–8 weeks.
How long does it take to modernize Legacy Website?
Typically 4–8 weeks for a focused engagement. After a short diagnostic we commit to a firm timeline so you know exactly what to expect.
Should we modernize legacy website code gradually or rebuild it from scratch?
Gradually, for most sites that handle logins, forms, payments or many indexed pages, because each step is small and reversible. For a brochure site with a handful of pages and no business logic, a clean rebuild is often simpler than running two stacks side by side. We make the call after inventorying routes, traffic and integrations.
Can old PHP pages and new pages share logins and sessions?
Yes. The simplest approach keeps the legacy application in charge of login and has the new app validate its session through a small endpoint or a shared session store such as Redis. Later, authentication moves to the new stack and the PHP side reads the new token. Both apps sit on the same domain, so cookies work for both.
Do we also have to replace our MySQL database?
Not at the start. The new front end reads the existing MySQL schema through a small API, so pages can move before any data work begins. Once most routes have migrated, we decide whether to clean up the schema, upgrade MySQL or move to PostgreSQL, based on data quality and what the new features need.
Keep exploring
Related tasks and resources to plan your next step with Krapton.
Let's get this off your plate
Send a 60-second brief on Modernize Legacy Website and a senior engineer replies within 24 hours with a plan and a fixed quote. NDA on day one, no retainer required.