Skip to main content

Legacy application modernization

Legacy app modernization

We fix or replace the old software your business runs on, one piece at a time. Your business keeps running the whole time. The price is fixed before we start, and anything over it is on us.

Have access to your code? Start with a free code audit. Then a fixed-price review: $15,000 for two weeks, up to $30,000 for six weeks. You keep the plan even if you don’t build with us.

TodayOld applicationRuns until each part moves overOrdersMoved overCustomersStill runningReportsStill runningPhase by phaseNew application, built beside itOrdersLiveCustomersBuildingReportsNextYour usersServed the whole time, by the old application or the new oneCustomersReportsOrdersOrdersTodayOld applicationOrdersMoved overCustomersStill runningReportsStill runningPhase by phaseNew applicationOrdersLiveCustomersBuildingReportsNextYour usersServed the whole timeCustomersReportsOrdersOrders

Legacy application modernization means fixing or replacing old software without shutting the business down. The Gnar Company does it two ways. We build new screens on top of the system you keep. Or we build a new system next to the old one and switch over piece by piece. Builds usually run $150K to $300K+. We built this for companies that have no engineers, or whose engineers are too busy to take it on.

Fixed milestone price

Any overage on us

Guaranteed outcome

The software works as specified or we fix it

Twelve-month bug-free warranty

On every build engagement

What changes

Your team stops working around the system.

Old applicationRunningReplacementBuildingBuilt beside it
Old applicationRunningReplacementBuildingBuilt beside it

The old system stays on

Your team keeps using the old system while we build. If you’re replacing it, each part moves over only when its replacement works.

Sales teamCustomerSearch customersOrdersOpen ordersOperationsToday’s workYour queueRecordsSearch records
Sales teamCustomerSearch customersOperationsToday’s workYour queue

Screens built for each job

Each team gets screens made for the work it does. New hires learn the job, not the workarounds.

Search customers, orders, historyCustomerFull historyReportReadyExportNo developer needed
Search your recordsCustomerFull historyReportReadyExportNo developer needed

Records your team can find

Your team searches its own records and pulls its own reports, without asking a developer.

Handed over with the codeTestsAutomated test suiteCode reviewPeer reviewedDocumentationWritten for hand-offRepositoryYours
Handed over with the codeTestsAutomated test suiteDocumentationWritten for hand-offRepositoryYours

Code you own

The new code comes with tests and written notes, and you own it. The next change won’t depend on the one person who knows the old code.

Two ways in

Fix the screens, or replace the system.

We pick the path with you in Gnar Discovery and Design (Discovery for short), our fixed-price review. Four things decide it: how the old system is built, how easy its data is to reach, whether whoever built it still supports it, and where your business is going. If your own engineers have the time and know what to build, we’ll tell you to do it yourselves.

Path 1

New screens on the system you keep

Use this when the old system still works, we can reach its data, and the screens are the problem. We build new screens on top of it, one set for each team. Your data stays where it is. You get a fixed price and the full guarantee on everything we build.

Old screenRec # ▾Status ▾Type ▾Code ▾Ref ▾Date ▾Flag ▾Notes ▾New screenCustomerSearch customersYour old systemKeeps every recordSavedUpdate
Old screenRec # ▾Status ▾Type ▾Code ▾New screenCustomerSearch customersYour old systemKeeps every recordSavedUpdate
Path 2

A new system, built next to the old one

Use this when the old system can’t be saved, or its vendor is forcing you off it. We build a new one next to it. The old system keeps running until each part of the new one is ready. Same deal: a fixed price and the full guarantee.

Old systemNew applicationPhase 1Phase 2Phase 3DataWorkflowsScreensThe old system runs until each piece is ready
Old systemNew appPhase 1Phase 2Phase 3DataWorkflowsScreensOld system runs until it is ready

Proof

Our work

Old tools rebuilt

Rebuilding the tools that help seniors save on property taxes

40%fewer clicks to complete an application, on average
14tools rebuilt while the old ones kept running
Read case study

Old and new side by side

Maintaining and improving code to support Fitbit’s clients

100k+Fitbit Plus clients moved to the new platform while Gnar maintained the legacy app
Allof Fitbit’s promises to its clients were kept during the move
Read case study

Old system rebuilt

Building software to help prevent abuse against adults with disabilities

500+organizations must check the registry
2023delivered that year, on time and within budget
Read case study
See all our work

How it works

How we’d work with you

Some old systems can be saved. Others have to be replaced. We find out which. Then we build the fix. It starts with a fixed-price review, before you commit to the build.

Your applicationWe map it firstCodeDataWorkflows
Your applicationWe map it firstCodeDataWorkflows
Step 1 · Two to six weeks

Find the right path

We map your system, your data and how your team works. Together we pick new screens or a new system. You get a step-by-step plan and a fixed price for the build. Builds usually run $150K to $300K+.

OrdersLiveCustomersBuildingReportsNext
OrdersLiveCustomersBuildingReportsNext
Step 2

Rebuild it

We rebuild it one piece at a time, starting with the part that will make the biggest difference. Each stage has its own fixed price, and the full guarantee covers it.

Support requestDoneWarranty fixDoneNew featureIn progress
Support requestDoneWarranty fixDoneNew featureIn progress
Step 3

Keep it running

After launch, we can keep it running and add new work for a monthly price agreed ahead of time. It’s optional, and you’re never locked in.

Our record

Why Gnar?

Common questions

Frequently asked questions

Still have questions?

How do you modernize a legacy application without stopping the business?

Build the new system next to the old one, and switch over one piece at a time. The Gnar Company starts with the part that will make the biggest difference. The old system keeps serving your users until its replacement works. For the AARP Foundation, the old tools kept running while we rebuilt 14 of them on React and Ruby on Rails.

Should we modernize our legacy system in place or rebuild it?

Rebuild only if the old system can’t be saved or its vendor is forcing you off it. If it still works and the screens are the problem, The Gnar Company builds new screens on top of it. Your data stays where it is. We make the call with you in Discovery, our fixed-price review. It looks at how the system is built, its data, its vendor and where your business is going.

How much does legacy application modernization cost?

It starts with Discovery, our fixed-price review: from two weeks and $15,000. You leave with a build plan and a guaranteed price. The plan is yours even if you don’t build with us. A modernization build at The Gnar Company usually runs $150K to $300K+. The price is fixed before work starts, and anything over it is on us.

Is there anything free before Discovery?

Yes, if you can give us access to your code. The Gnar Company does a free code audit: we read your code and tell you what shape it’s in. We sign an NDA (an agreement to keep your code confidential) before we look. The answer can be that your code is fine. If you go ahead, Discovery is the paid next step. It ends with a build plan and a fixed price.

What are the signs a legacy system needs to be modernized or replaced?

Your team spends its day working around the system. Signs The Gnar Company sees often: spreadsheets kept next to it, new hires who take months to learn it, data nobody can pull without a developer, a vendor dropping support, and changes that feel risky every time. Discovery tells you which fix you need: new screens or a new system.

Who can rebuild our 20-year-old custom software?

The Gnar Company can. We read the old code, map its data and how your team uses it, and work out the rules nobody wrote down. The Massachusetts Disabled Persons Protection Commission (DPPC) ran its Abuser Registry on an old system that couldn’t keep up. We rebuilt it in Ruby on Rails on AWS. It was delivered on time and within budget in 2023.

Can you modernize our application if we have no in-house developers?

Yes. The Gnar Company built this service for companies that have no engineers, or whose engineers are too busy to take it on. A senior team, all based in the U.S., runs it from Discovery to launch. And if your own engineers do have the time and know what to build, we’ll tell you to do it yourselves.

Can the new application work with the systems we are keeping?

Usually, yes. The Gnar Company connects the new system to the software you’re keeping, to other companies’ tools and to the online services you use. While old and new run side by side, we keep the data in sync between them. Discovery first checks how easy each system’s data is to reach.

What does the guarantee cover on a modernization project?

It covers both paths, new screens or a new system, plus Discovery and our monthly support. On every build, The Gnar Company promises three things. The price is fixed, and anything over it is on us. The software works the way we agreed it would, or we fix it. And the build carries a twelve-month bug-free warranty.

Can you move us off an old platform like Access, FileMaker or an aging .NET app?

Yes. The Gnar Company can rebuild an app like that as a modern web app. We map its screens, its data and its rules, rebuild them, then move the data over piece by piece. The old app keeps running until each new piece is ready. If the old platform needs its own expert, we work with one.

Who will be on my team?

A small senior team from The Gnar Company: engineers based in the U.S. and a product manager. Design, web and mobile work are all done by our own people. No teams outside the U.S. No junior developers handed the work after a senior sales pitch. The team maps your old system first, then builds the new screens or the new system.

What happens after the new application launches?

The code is yours. The Gnar Company hands it over in a repository you own, with written notes so another team can pick it up. For twelve months, we fix any part that doesn’t work the way we agreed, at no charge. Ongoing support and new work are separate, through an optional monthly plan. You are never locked in.

Your applicationMapped and priced before the build startsCodeDataVendorBusiness
Your applicationMapped and priced firstCodeDataVendorBusiness

Start here

Start with a fixed price, not a guess.

Have access to your code? Ask for our free code audit first. Then a fixed-price review: $15,000 for two weeks, up to $30,000 for six weeks. You keep the plan and its price, even if you don’t build with us.

Talk to us about modernization

Let’s Talk

Contact Us

Tell us what you’re trying to build or fix.