Migrations & Modernization · Houston, TX

Legacy modernization & migrations: move the system without stopping the business.

A good migration is boring: old and new run side by side, the numbers reconcile, the cutover happens in a quiet window with a tested way back, and nobody's Monday is ruined. That boredom is the product — whether it's a hosting move or full legacy modernization.

Why now

Six ways this conversation usually starts

Nobody wakes up wanting a migration. It arrives as a date on a letter, a renewal quote, or a resignation.

The vendor set an end-of-life date

Support ends on a date somebody else picked, the version you run stops getting patches, and the upgrade path in the letter is really a new product with a new price. The date is real; the panic doesn't have to be.

The renewal came back at three times the price

The software got acquired, the plan you were on no longer exists, and the quote assumes you have nowhere else to go. Knowing what it would take to leave is worth having before you sign — even if you end up staying.

The server is out of warranty and under a desk

One machine, no spare, backups nobody has ever restored from, and an OS that stopped getting security updates two years ago. It works right up until the morning it doesn't.

Nobody left knows how it works

The person who built it retired, contracted, or stopped answering. What's left is a running system, a few habits, and a spreadsheet of workarounds in somebody's inbox.

An auditor, an insurer, or a customer asked

A cyber-insurance questionnaire, a security review from a big customer, or an auditor asking who has access. Unsupported software is a hard question to answer well, and the answer is usually a project.

The workaround quietly became the process

Export to Excel, fix it by hand, import it somewhere else — every month, by the same person. That's a system that stopped fitting the business, paid for in salary instead of software.

What we migrate

If it's stuck somewhere, we can probably move it

From a website on a dying host to the AS/400 that still runs order entry.

Mainframe, AS/400 & COBOL systems

The green screen that still runs the business, on a platform with a shrinking pool of people who can maintain it.

  • COBOL, Fortran, RPG, CL, and JCL read and documented before anything is proposed
  • DB2, VSAM, and flat-file extracts reconciled record for record
  • An API in front first, so the terminal keeps working while pieces move
  • Business rules re-implemented in Java, C#, or Python — languages you can actually hire for
  • The green screen retired only after the replacement matches it, field for field

Language & framework upgrades

VB6, Python 2, old PHP, .NET Framework — modernized incrementally, while the business keeps running on it.

  • Strangler-style migration: replace pieces, never stop the whole
  • Tests written against current behavior before anything changes
  • VB6 carried to C#, Python 2 to 3, jQuery front ends rewritten in TypeScript, aging Java brought up to modern Java
  • A codebase your next hire will recognize

Desktop apps to the Web

VB6, Access, Delphi, or FoxPro on every PC — rebuilt as a browser application people can use from a warehouse, a truck, or home.

  • No more install-on-every-machine, and no more "it only works on the back-office PC"
  • Remote and tablet access without Citrix, RDP, or a VPN per user
  • Screens rebuilt to match the workflow people actually use, not the 1998 menu tree
  • Printing, scanners, and label printers kept working — usually the hard part

Database engine & version upgrades

Oracle to PostgreSQL, an end-of-life SQL Server, MySQL to a supported release — usually a licence bill or a support date, not a feature.

  • Schema, stored procedures, and views converted between T-SQL, PL/SQL, and PL/pgSQL — not just the tables
  • Replayed against real captured queries so behavior changes surface early
  • Collation, date handling, and rounding differences found before month-end does
  • A rehearsed cutover with the old instance kept read-only

Spreadsheets & Access to real databases

The workbook five people edit at once, or the Access app from 2009, rebuilt on a database that won't corrupt on Tuesday.

  • Data cleanup and de-duplication as part of the move
  • A Web front end your team can use without retraining
  • The old file kept, read-only, until you trust the new one

ERP & accounting system moves

QuickBooks Desktop to Online, an end-of-life Dynamics or Sage version, or an ERP module that outgrew the spreadsheet feeding it.

  • Chart of accounts, open balances, and history moved with a tie-out you can audit
  • Cutover timed to a period close, not to a calendar invite
  • Customer, item, and vendor records de-duplicated on the way across
  • Your CPA or controller signs off on the numbers — we don't give tax advice

Platform & SaaS migrations

Off software that got acquired, tripled its price, or is being shut down — data, workflows, and history intact.

  • Export, transform, and load with reconciliation counts you can audit
  • Replacement with another product or a custom tool, honestly compared
  • Integrations re-pointed so nothing downstream quietly breaks

Report & BI migrations

Crystal Reports, SSRS, and the Access and Excel reports that quietly became the monthly pack, moved onto something supported.

  • Every report inventoried first — most sets have a third nobody has opened in a year
  • Rebuilt in Power BI or SSRS with the numbers matched against the old output
  • The business logic buried in the report moved into the data layer where it belongs
  • Scheduling, distribution, and permissions rebuilt, not left to a person's Outlook rule

Server & cloud migrations

From the machine under the desk or the end-of-life OS to hosting that is patched, backed up, and monitored.

  • On-prem to AWS, Azure, or a plain VPS — sized to the bill you can justify
  • Staged cutover with a parallel run, not a big-bang weekend
  • Backups and monitoring proven before the old machine is unplugged

Website & hosting moves

Off a dying host, an expired agency relationship, or a page builder you've outgrown — without losing your content or your Google ranking.

  • Full content, DNS, and email cutover with a rollback plan
  • Redirects so your links and search ranking survive the move
  • Everything lands in accounts that belong to you

Email & domain moves

Consolidating domains, moving to Microsoft 365 or Google Workspace, or untangling email from a host you are leaving.

  • Mailboxes, aliases, and history moved without dropped mail
  • SPF, DKIM, and DMARC set up so your mail keeps landing
  • DNS ownership returned to you, documented

File shares, documents & records

The mapped drive with twenty years of everything on it, moved to SharePoint, Microsoft 365, or Google Workspace — permissions and all.

  • Structure and permissions rebuilt deliberately instead of copied wholesale
  • Long paths, duplicate copies, and orphaned folders resolved before the move
  • Scanned archives and document systems indexed so things stay findable
  • Retention and legal-hold requirements handled as part of the plan
Choosing the path

Seven options, and only two of them are a project

Every system we assess gets measured against this ladder, cheapest first. Most of what we look at should stay where it is or be switched off — and an assessment that says so has done its job.

Path What it means When it's the right call
Retain Leave it exactly where it is, on purpose, with the risks written down. It works, it's contained, and the money buys more somewhere else. Revisit on a date, not on a feeling.
Retire Turn it off and archive the data. No replacement gets built. Two people use it, both have stopped, and what it holds is really a records-retention question.
Rehost Same software, better floor — moved to supported hosting or a VM as-is. The application is fine and the hardware or the OS is the risk. Fastest way to stop the bleeding.
Replatform Keep the application, change what it stands on: database engine, runtime version, hosting model. The licence bill, an unsupported runtime, or a database version is the constraint — not the logic.
Refactor Modernize the code in place, one piece at a time, behind a stable boundary. Nothing stops. The business logic is worth keeping and nobody can afford a freeze. The usual answer for systems that still earn their keep.
Rebuild Write the replacement, run it beside the old one, cut over in stages. The rules changed so much that the old system is arguing with the business. Costly, so it needs evidence first.
Replace Buy a product, migrate the data and history into it, keep the integrations pointed somewhere sane. What you do here isn't your differentiator and a good product exists. We'll say so — and help you leave later if it stops fitting.

Most engagements are a mix — retire two things, rehost one, refactor the part that earns its keep. Picking one path for an entire estate is how migrations end up on a whiteboard for three years.

The person who built it is gone?

That's the starting point for most of the migrations we do — no documentation, no source code sometimes, and one person who half-remembers how the nightly job works. We start from the running system and the data, and the migration ends with the documentation the old system never had. When the code itself is the risk — no tests, no safe way to change anything — code rescue comes first. If you're not ready to move anything yet, a short paid assessment still leaves you with a map of what you have and what it would take.

How a safe migration runs

  1. 1

    Assess

    A short paid look at what exists: what it stores, what it talks to, who depends on it, and where the bodies are buried. You get a phased, fixed-price plan. (Bigger build-vs-buy questions get a proper feasibility study first.)

  2. 2

    Dry run

    Migrate a copy, reconcile the counts and totals, and rehearse the cutover. Every surprise found here is one that doesn't happen in production.

  3. 3

    Parallel run & cutover

    Old and new side by side until the numbers agree, then a cutover in a quiet window with the rollback tested, not hoped for.

  4. 4

    Decommission

    The old system stays read-only until the new one has earned trust. Only then does it get turned off — and you get the documentation and a final archive.

Where it pairs well

  • An API layer over the old core is often phase one — that's system integration, and it lets the system be replaced behind a stable boundary
  • If the system is slow rather than stuck, performance tuning may beat migrating it at all
  • Undocumented code with no tests gets code rescue before anything moves
  • When the replacement has to be built rather than bought, that's custom software — same phasing, same reconciliation
  • Moving a WMS or an ERP means re-onboarding trading partners, so the EDI maps and connections travel with it
  • Changing warehouse systems? A 3PL reporting layer keeps the history in a database you own, so old and new reconcile on the same numbers
  • If the process itself is the problem, fix it before it gets rebuilt in a new system — that's Lean Six Sigma
  • How this runs in practice: the case studies include several migrations that ran exactly this playbook

No big-bang weekends

Most systems move one piece at a time — each step small enough to verify, reverse, or pause without drama.

Reconciliation you can audit

Record counts, totals, and spot checks compared between systems. You sign off on numbers, not on reassurance.

Rollback is a plan, not a hope

Every cutover has a rehearsed way back. If something's wrong, you're back on the old system in minutes, not explaining an outage.

Sometimes the answer is "stay put"

If the assessment says the migration isn't worth it yet, that's what the report says. Cheaper for you, and we'd rather be the honest referral.

Same playbook, no move

Modernization work that isn't a migration

Half of what gets asked for here never becomes a system move: a map before a budget, a handover from a vendor who stopped answering, an old system switched off properly. Each of these stands on its own.

Assessment & modernization roadmap

A short paid look at what you have: what it stores, what it talks to, who depends on it, and what each option would actually cost. You get a phased plan you can take to anyone — including the finding that you should stay put for now.

Vendor exit & handover

The agency stopped answering, or the contract is ending. We get the domains, DNS, source code, cloud accounts, and credentials back into your name, document what arrives, and tell you honestly what's missing.

Merger & multi-entity consolidation

Two companies, two of everything — two customer lists, two charts of accounts, two email domains. We merge what should be merged, keep what has to stay separate, and leave an audit trail for both.

Data cleanup before the move

A migration is the cheapest moment to fix duplicates, dead records, and the free-text field that holds four different things. Done right, the new system starts clean instead of inheriting the mess.

Archive & decommission

Turning the old system off properly: a readable archive of the data, retention requirements met, licences and hosting actually cancelled, and a written record of what was retired and when.

Cutover support & hypercare

The two weeks after go-live, when the exceptions show up: somebody on the phone, the error queue watched, the rollback still live, and the documentation and training your team keeps afterward.

Cleaning the data is its own discipline once the volume gets real — that's data entry & analysis. Rebuilding the reports on the other side is Power BI & Power Platform.

Toolkit

What we work in

Old and new both count. If your platform isn't listed, ask — the ones that aren't here are usually a reading problem, not a barrier.

COBOL Fortran RPG & CL JCL AS/400 & IBM i DB2 VSAM Ada & SPARK VB6 & VBA Classic ASP Delphi FoxPro MS Access & Jet .NET Framework → .NET Python 2 → 3 PHP 5 → 8 Perl Java 8 → modern Java C & C++ services jQuery → modern JS Oracle → PostgreSQL SQL Server upgrades MySQL & MariaDB SQLite SSIS & ETL rewrites Crystal Reports SSRS Power BI Windows Server & IIS Linux, Apache & nginx Docker & containers AWS Azure Plain VPS hosting Microsoft 365 Google Workspace SharePoint & OneDrive Exchange & mail routing SPF, DKIM & DMARC DNS & domain transfers WordPress Shopify & WooCommerce QuickBooks & Sage Dynamics GP Git, SVN & TFS Strangler-fig migration Change data capture Parallel-run reconciliation
Questions we get

Straight answers

How much downtime should we expect?

Usually none your customers notice. We run old and new in parallel, cut over in a quiet window with a tested rollback, and keep the old system available read-only until the new one has earned trust.

How do we know no data gets lost?

Reconciliation you can audit: record counts, totals, and spot checks compared between systems before and after, plus at least one full dry run. You sign off on the numbers, not on our reassurance.

The person who built our system is gone and nothing is documented.

That is the normal starting point, not a dealbreaker. We work from the running system, the data, and the people who use it — and the migration ends with the documentation the old system never had.

Do we have to migrate everything at once?

No, and you usually shouldn't. Most of our migrations move one piece at a time behind the scenes — each step small enough to verify, reverse, or pause without drama.

What does a migration cost?

It starts with a short paid assessment: what you have, what it talks to, and where the bodies are buried. That produces a phased, fixed-price plan — and sometimes the honest finding that you should stay put for now.

Will our team have to learn a new way of working?

Only where the old way was the problem. Where a workflow works, the new system keeps it; where it doesn't, changes come with a walkthrough and a transition period, not a surprise on Monday morning.

We don't have the source code. Can it still be migrated?

Usually yes. Plenty of what we move has no source — the behavior gets recovered from the running system, the database, the screens, and the people who use it daily, and that becomes the specification the replacement is tested against. Where a binary genuinely can't be replaced yet, rehosting it somewhere supported buys you time to do this properly.

Will we lose our Google rankings if the website moves?

Not if the move is done properly. Every existing URL gets a 301 to its new home, the content and titles come across intact, and we watch Search Console for crawl errors afterward. Rankings wobble for a week or two on any move; they come back. What loses rankings is a relaunch that quietly drops half the pages and every inbound link with them.

How long does a migration take?

The assessment is usually one to three weeks. After that, a hosting or email move is days; a spreadsheet or Access rebuild is weeks; a database engine change or a line-of-business system is months, delivered in phases you can see working rather than one long silence. The plan gives you dates per phase, and any of them can be paused without stranding you mid-move.

Do we get locked into you afterward?

No. We don't sell a platform, and there's nothing here that only we can run. You own the code, the accounts, and the data; the documentation is written for whoever comes next, and we'll hand it to your internal team or another firm without drama. Staying should be a preference, not a consequence.

Can you work with our existing IT provider or vendor?

Yes, and often that's the cheapest way to run it — they hold the access, the history, and the relationship, and we do the part they don't staff for. We're happy to work under their change process. If the incumbent is the reason nothing is moving, that's a different conversation, and we'll have it directly rather than around them.

Can we just delete the old system once we're live?

Not immediately, and sometimes not for years. Records-retention rules, tax and audit requirements, warranty history, and open litigation all outlive the software that holds them. Decommissioning properly means a readable archive, a documented retention period, and only then turning it off and cancelling the licence.

We just acquired a company and have two of everything. Where do we start?

With the list of what's genuinely duplicated versus what only looks it: customers, items, chart of accounts, email domains, and the reporting that has to combine both by a deadline. Some of it merges, some of it should stay separate for good reasons, and knowing which is which is most of the work. That's a consolidation plan before it's a migration.

Do you work outside Houston?

Yes. Most of this work is remote and always has been — the systems are reachable, the calls are on video, and the reconciliation is the same either way. Houston and the surrounding metro get on-site time when it helps, which for warehouse and plant-floor cutovers it usually does.

Get in touch

What's stuck where it is?

Tell us what you're running and we'll tell you what a safe move looks like — phased, priced, and reversible.

Prefer to talk?

Call 832-598-8234 or email msco@stoneagesoftware.com. Houston, Texas — serving Houston, The Woodlands, Conroe, Sugar Land, Katy, Pearland, and the Greater Houston metro.

What happens next

We read your message, an engineer replies with questions or a straight answer, and if it's worth a call we book one. No drip campaign, no handoff to sales.

No obligation — we reply within one business day. This form sends your details to Stone Age Software LLC so we can respond to you. See our privacy policy for how we handle them. This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.