businessbasic.cloud Free report

businessbasic.cloud · An honest comparison

Still on Business Basic?Here are all four options.

If the company runs on Business Basic, you have exactly four ways forward: keep paying and keep the box, rewrite to a modern ERP, lift the whole thing onto a cloud VM, or move the runtime underneath it. This page lays out all four across the twelve dimensions that actually decide it — and marks which option genuinely wins each row.

See the comparison Skip to how to decide
We make option four. It wins four rows of twelve.

Doing nothing wins five — more than we do.
We left the table that way because that is what the rows say, and because you would have worked it out inside a week. Published by Unique Photo · Fairfield, New Jersey · est. 1947.

  • Option 01

    Do nothing

    Renew the license. Keep the server. Revisit it next year.

    Up-front
    Nothing
    Ongoing
    Unchanged, rising
    In 3 years
    Same decision

  • Option 02

    Rewrite to a modern ERP

    Net-new system, modern stack, a vendor with a roadmap.

    Up-front
    Seven figures
    Ongoing
    New subscription
    In 3 years
    Live, or written off

  • Option 03

    Lift and shift to a cloud VM

    Same runtime, same license, someone else's hardware.

    Up-front
    Low
    Ongoing
    Higher
    In 3 years
    Same problem

  • Option 04 This is us

    Move the runtime

    Programs and data unchanged. The interpreter beneath them is replaced.

    Up-front
    Low
    Ongoing
    Half the license
    In 3 years
    No box, half the bill

01 The four options

Every option, argued properly — including the three that aren't us.

A comparison where the author wins every row is an advertisement. Below, each option gets the strongest honest case for it and the real bill that comes with it. Three of these are not our product, and two of them are right for some companies reading this.

Do nothing

Renew the license, keep the server, and put the decision back on the shelf for another year.

This is the option nobody pitches you, and it is the one most companies actually choose — not by deciding, but by not deciding. It deserves a fair hearing anyway, because sometimes it is simply correct. The software works. That is the awkward part: order entry written decades ago still ships product every day, and no project you don't run can overrun, blow its budget, or land on the wrong side of a fiscal year.

If your hardware is healthy, your license is small against your P&L, and the person who understands the application is not going anywhere for five years, then doing nothing is a defensible position and anyone telling you otherwise is selling something. We would rather say that out loud than pretend urgency you don't have.

What doing nothing does not do is get cheaper. The invoice arrives again next year, and it is larger. The hardware ages along a curve that ends abruptly rather than gently. The bench of people who can read that code is shrinking nationally, not just at your company. Doing nothing is free this year and expensive in the year the box dies — and you don't pick that year.

Genuinely in its favour

  • Costs nothing up front. No capital request, no board slide, no project.
  • Zero execution risk this year. Nothing can fail if nothing is attempted.
  • Nobody's week changes. No retraining, no parallel running, no weekend.
  • The application keeps doing the job it has always done, correctly.
  • Every other option stays open. You have spent nothing and closed nothing off.

What it actually costs

  • The per-seat license never ends, and it rises when you add a warehouse.
  • Hardware failure is a when, not an if — and it picks the date, not you.
  • The one person who understands the system gets a year closer to retiring.
  • The decision gets harder and more expensive every year you defer it.
  • Your disaster recovery is whatever it is today, including the restore nobody has tested end to end.

Right for you if

The hardware is healthy, the license is a rounding error against your P&L, and the person who maintains the application will still be here in five years. Or if you expect to sell or wind down the business before the hardware gives out — in which case starting a project whose payback lands after you've left is the wrong call, and nobody should talk you into one.

Rewrite to a modern ERP

Replace the application entirely: a net-new system on a modern stack, from a vendor with a product roadmap.

The honest case for this is stronger than anyone selling a legacy runtime likes to admit, so here it is. You get a system built this decade. A real vendor with a roadmap and a release cadence. A twenty-four-hour support organization that is contractually on the hook at three in the morning. An ecosystem of implementers you can hire from, and a hiring pool that is not six people who all know each other. An API surface other software already expects. Mobile and warehouse tooling that exists rather than being written. Reporting that a finance team can drive without asking anyone.

And there is a class of company for which this is the only right answer: if your business has genuinely outgrown its processes — you're acquiring, you need multi-entity consolidation, your people are working around the system instead of inside it — then no runtime swap helps you at all. The problem isn't the interpreter. It's the model underneath, and the only way to change the model is to change the application.

Then there is the bill. Expect seven figures once licenses, implementation, integration, data migration and the backfill for the staff you second to the project are all counted, and expect it to run multi-year. Large ERP replacements fail or overrun often enough that your board has already heard the stories — and they usually fail in the same place. Thirty years of encoded business rules exist only in the code. Every one of them has to be re-derived, re-specified and re-implemented by people who weren't there when the rule was made, from a system whose documentation is the source.

Genuinely in its favour

  • A real future: roadmap, releases, and a vendor whose business is this product.
  • Twenty-four-hour support with an SLA. A contract, not a favour.
  • A hiring pool, an implementer ecosystem, and training that already exists.
  • Modern integrations, reporting and mobile tooling out of the box.
  • The only option that can change what the business is actually able to do.

What it actually costs

  • Seven figures, and multi-year. Value arrives at the end, if it arrives.
  • Undocumented business rules must be re-derived from the code that encodes them.
  • Your best operators are seconded to the project on top of their day jobs.
  • Every user retrains: new interface, new workflow, new vocabulary.
  • Historical data is what gets cut when the schedule slips. It usually slips.
  • Once the old system is retired there is no exit, and abandoning late means writing off the spend.

Right for you if

The software itself is the problem — not its age. If you need capabilities the application does not have and would not have on any interpreter, buy the new system. We would rather tell you that here than after an assessment. Take the free compatibility report on your way out, though: every rewrite RFP needs an inventory of exactly what is being replaced, and ours is automated and costs nothing.

Lift and shift to a cloud VM

Same application, same runtime, same license — running on somebody else's hardware instead of yours.

Provision a virtual machine, install the same commercial interpreter you license today, copy the files across, repoint the terminals. It is the cheapest correct answer to one specific problem — the box — and if the box is genuinely your only problem, this is the right answer and you should do it this quarter rather than reading the rest of this page.

It is fast, it is well understood, it is trivially reversible, and the environment you land in has better snapshot, backup and recovery options than a decade-old server in a closet has ever had. Nobody retrains. No code changes. The work is measured in weeks and most of the risk is in things you can enumerate in advance: printing, anything bolted to a physical device, and latency for users who are suddenly a long way from their data.

What it does not do is touch either of the other two problems. The per-seat license follows you to the new host and keeps arriving on the same schedule. The single-vendor dependency is exactly as deep on Tuesday as it was on Monday. And you have now added a monthly cloud bill underneath an invoice that did not shrink, so the run rate goes up rather than down. You have changed where the problem lives, not whether you have it.

Genuinely in its favour

  • Fast and cheap. Weeks, not years, and no capital project.
  • Solves the hardware problem outright — the closet is empty.
  • Snapshots, backups and real recovery options become available immediately.
  • No program changes and no user retraining whatsoever.
  • The easiest exit of the four: move the machine again, or move it back.

What it actually costs

  • The license survives the move intact, per seat, forever.
  • Your run rate rises: two invoices where there used to be one.
  • Single-vendor dependency is completely unchanged.
  • Printing and device-bound work is the tail that always takes longer than planned.
  • Remote users can end up further from their data than they were.
  • The real decision is deferred again, at a modest annual cost for deferring it.

Right for you if

The hardware is the whole complaint. The license is affordable, the vendor relationship is fine, and you simply want an aging machine off your balance sheet and out of your risk register. That is a real and reasonable position, and this is the fastest route to it.

Move the runtime

This is our product

Your programs and your keyed data files do not change. The interpreter underneath them does.

There is exactly one component in that stack that has to change, and it isn't your code, your data, your screens or your people. It is the interpreter. We wrote a clean-room Business Basic runtime — from the published language definition and from measured behaviour, not from anyone else's source — and we run it as a managed cloud service. Your source runs as it sits. Your data files stay in their native format with their existing keys. Half the license you pay now, and hosting, backups and disaster recovery are included rather than billed.

We did not build this to sell it. We built it because we run on it: Unique Photo is a distributor in Fairfield, New Jersey, in business since 1947, and our own inventory, orders, purchasing and accounting go through this engine. If it gets a number wrong, our warehouse stops shipping before yours does.

Now the parts that are not flattering, in the same paragraph rather than in an appendix. We are pre-GA and taking design partners, not self-serve production traffic. The report writer and print spooling are being rewritten rather than emulated, so printing is the one thing on the screen that will change. The SQL layer has no joins or aggregates yet. We are cloud-only — there is no version of this you run on your own hardware. And we are a young product from a company that has never sold software before. Every one of those is in the comparison table below, in the rows where it costs us the win.

Genuinely in its favour

  • Programs run unmodified. Not ported, not converted, not "mostly compatible".
  • Data files stay in native format with their existing keys. Nothing is re-encoded.
  • Half the runtime license, with hosting, backups and DR included, never a line item.
  • Users retrain on nothing: same screens, same F-keys, same field editing.
  • Proven before you commit — your system runs in parallel with the one you have, and the output is diffed value by value.
  • Reversible by design. The old box still holds your programs and your unconverted files.

Where we are weak

  • Pre-GA. Design partners only, and we will not pretend otherwise.
  • The report writer is being rewritten, not emulated — printing behaviour changes.
  • The SQL layer has no joins or aggregates yet.
  • A small number of vendor-encrypted third-party programs need source supplied.
  • Cloud only. There is no on-premises build and no perpetual license.
  • We are small. There is no twenty-four-hour support desk with an SLA behind us the way there is behind a modern ERP vendor.

Right for you if

The license, the box and the shrinking bench are all problems at once — and the application itself is fine. That is a narrow description, and it is exactly the company we were when we started writing this. If your reporting depends on multi-table joins today, or printing is heavily customized and load-bearing, we are not ready for you yet; take the free report anyway and check back.

02 Side by side

Twelve dimensions. Four options. One winner per row.

These are the dimensions that decide it in the room — not feature counts. The green cell in each row is the option that genuinely wins it. We win four of the twelve. Doing nothing wins five. Read the rows we lose first; they are the ones that tell you something.

Scroll the table sideways →

Four options for a Business Basic system compared across twelve dimensions. Each row marks the option that wins it.
Dimension Option 01 Do nothing Keep the license, keep the box Option 02 Rewrite Replace with a modern ERP Option 03 Lift and shift Same runtime, cloud VM Option 04 Move the runtime This is our product
Up-front costYear one NothingWins this row.No project, no capital request, no board slide. Renew and carry on. Seven figuresLicenses, implementation, integration, data migration, and backfill for the staff you second to the project. LowA migration weekend, some testing, and whatever your vendor charges to re-issue the license on new hardware. LowA free automated report, then a fixed-fee assessment that is credited in full against the migration.
Ongoing costEvery year after Unchanged, and risingThe per-seat license continues and grows. The hardware refresh is deferred, not avoided. A new subscriptionWhatever the new vendor charges, plus the integration surface you now own and maintain. Sometimes less than today. Often not. Higher than todayThe license survives the move and you have added a cloud bill underneath it. Two invoices where there was one. Half the licenseWins this row.Half of what you pay for the runtime now, with hosting, backups and disaster recovery included and never a line item.
Time to valueUntil something is better Not applicableNothing takes any time, because nothing improves. The clock is only running against you. Multi-yearSelection, implementation, parallel running, and a go-live date that moves. Value arrives at the end, if it arrives. WeeksWins this row.Provision, copy, test, cut over. The fastest real change available to you, and we are not going to claim otherwise. Weeks to a few monthsReport in days, assessment in weeks, then a mirror runs as long as you want one. Most people want a clean month-end close diffed first.
Risk of failureOf the project itself Lowest — this yearWins this row.Nothing can go wrong with a project you don't run. The risk is deferred to a year you don't get to choose. Highest of the fourReplacements fail or overrun often enough that your board already knows the stories. The failure point is usually the undocumented rules. LowWell-understood work. The exposure is hardware assumptions, printing, and anything tied to the physical machine. Moderate — we are pre-GAMitigated by parallel running and by the old system still sitting there. But we are not generally available, and that is a real risk you are taking.
Business disruptionWhat your week looks like NoneWins this row.Nobody's week changes. No project meetings, no parallel running, no weekend. Severe, for yearsYour best operators are seconded to the project on top of their day jobs, through at least one go-live and usually two. A weekend, plus a tailThe move itself is short. Printing and peripherals are the part that runs on afterwards. A weekend, plus assessmentFreeze Friday, run parallel, live Monday. The assessment work before it is mostly ours, not yours.
Do your programs change?The source you own No — not one lineWins this row.Nothing moves, so nothing can break. This is the cleanest possible answer and it belongs to doing nothing. They are replacedThirty years of encoded rules have to be re-derived, re-specified and re-implemented — most of them written down nowhere else. NoSame runtime, same binaries. You revalidate against a new operating system and new hardware, which is not nothing. No, with one exceptionPrograms run as they sit. The exception: a small number of vendor-encrypted third-party programs need source supplied before we can run them.
Do your users retrain?The people on the floor NoWins this row.Same screens, same keys, same muscle memory, same everything. Nobody notices, because nothing happened. CompletelyNew interface, new workflow, new vocabulary, for every person who touches the system — warehouse included. NoSame screens. Watch latency if your users are now a long way from where the data lives. No, except printingScreens, F-keys and field editing are unchanged and measured. Printing does change, because we are rewriting the report writer rather than emulating it.
What happens to your data?The files themselves Stays exactly where it isOn the same disks, under the recovery plan you actually have — which for most shops is a backup nobody has restored end to end. Migrated and re-modelledExtract, map, transform, reconcile. History is the part that gets cut when the schedule slips. Copied as-isSame files, same format, someone else's disk. Same backup discipline you had, unless you deliberately change it. Untouched, native, yoursWins this row.The same keyed files, no conversion and no re-encoding, handed back on request. Snapshots, backups and DR included.
Vendor lock-inWho has you Unchanged, and hardeningOne vendor for the runtime, one person who understands the application — and the person is retiring first. Deepest of the fourA new vendor's data model, release cadence and license terms, for the next twenty years. Leaving means doing this again. UnchangedThe license moved to a new machine. The dependency did not move at all. Lowest, with a caveatWins this row.Nothing is converted or re-encoded; programs and files stay yours in native format and come back on request. Caveat: we are cloud-only, and we are young.
Exit pathIf this goes wrong Nothing to exitYou are already there. But the exit you keep postponing costs more every year the bench shrinks. Effectively none, mid-flightOnce the old system is decommissioned there is no going back, and abandoning late means writing off the spend. TrivialWins this row.Same runtime, same license. Move the machine somewhere else, or move it straight back. Cleanest exit on the table. Simple, and deliberately soYour old box still holds your programs and your unconverted files. Roll back to the runtime you have today. Close second, not first.
Who do you call at 2am?When it stops Your own personThe one who understands it. If they have retired, or they are on holiday, the honest answer is nobody. A 24/7 desk with an SLAWins this row.A real support organization, contractually on the hook and staffed at three in the morning. This is a genuine advantage and we do not have it yet. Three different numbersCloud provider for the machine, runtime vendor for the license, your own person for the application. Expect to referee. Us — and we are smallYou reach the engineers who wrote the engine, not a script. We are paged when our own warehouse stops, which is usually the same page. But we are a small team.
Where it leaves youIn three years The same decision, harderOlder hardware, a smaller bench, a larger invoice, and this exact conversation from a worse starting position. A modern system, or a write-offIf it landed you have a genuine future and a support contract. If it didn't, you have neither — and the old system anyway. The same problem, new addressThe license and the single-vendor dependency both survived the move. The closet is empty. The invoice isn't. Half the invoice, no boxWins this row.Programs unchanged, data unchanged, hardware gone, license halved — and the gaps listed on this page either closed or still clearly listed.

Green cell = wins that row 12 dimensions · 4 options · 1 winner each Published by the vendor of option 04

  • 5/12

    Do nothing

    Wins more rows than anyone on this page, including us.

  • 1/12

    Rewrite

    One row — and it is the one a CFO cares about at 2am.

  • 2/12

    Lift and shift

    Fastest to finish, easiest to undo. Both genuinely ours to lose.

  • 4/12

    Move the runtime

    Second place by row count. First place on every row about year three.

How to read the tally

Doing nothing wins five rows and we win four. That is the honest count, and it is not the argument we would have written if we were making it up.

Look at which rows, though. Every row doing nothing wins is about this year: what it costs now, what it disrupts now, what nobody has to learn now. Every row it loses is about the next ten — the invoice, the data, the dependency, the exit, and where you are standing in three years. Doing nothing is not a strategy that wins. It is a strategy that postpones, and it is priced accordingly.

The right answer is not the same for every reader. It is knowable, though.

Four options, and the one that fits depends on about six facts about your company. Here they are, with the answers spelled out — including the two where we tell you to stop reading.

03 How to decide

Six statements. Whichever one is true of you is your answer.

Read down until one of these describes your company. If two of them do, take the more conservative of the two — that rule has never made anybody worse off.

If

You expect to sell the company, merge it, or wind it down within about five years.

Then

Do nothing. Option 01.

Don't start a project whose payback lands after you've left. Renew the license, spend the money on something that shows up in the valuation, and hand the decision to whoever buys you. Anyone pushing you off this position is optimizing for their quarter, not yours.

If

The application genuinely cannot do what the business now needs — multi-entity consolidation, acquisitions, capabilities your people work around every day.

Then

Rewrite. Option 02. Stop reading this page.

This is the one where we disqualify ourselves. A different interpreter runs the same program, and the same program still won't consolidate three entities. The problem is the model, not the runtime beneath it. Go and get quotes — and take the free report on the way so your RFP starts with an accurate inventory of what you are replacing.

If

The hardware is your only actual complaint. The license is affordable and the vendor relationship is fine.

Then

Lift and shift. Option 03.

It is the cheapest correct answer to that specific problem, and you can be done this quarter. Do it, get the snapshots and the recovery plan you have never had, and revisit the license question when the renewal next annoys you.

If

The license, the aging box and the shrinking bench are all problems at once — and the application itself is doing its job correctly.

Then

Move the runtime. Option 04.

That is the narrow case we built for, and it is a precise description of the company we were when we started. Programs unchanged, data unchanged, half the license, hosting included, and the old system still sitting there while a mirror proves the new one.

If

Your reporting depends on multi-table joins or aggregate queries today, or printing is heavily customized and load-bearing.

Then

Not us. Not yet.

Our SQL layer has no joins or aggregates, and we are rewriting the report writer rather than emulating it. Those are the two places we would cost you real work today. Take the free report so you know exactly how much of your corpus sits on them, keep your current tooling, and check back.

If

You cannot answer any of the above, because nobody currently knows what is actually installed, or which programs are still used.

Then

Start with the inventory. It is free.

You cannot choose between four options with an unknown denominator, and this is more common than anyone admits in a meeting. The compatibility report is automated and costs nothing, and it is useful whichever of the four you end up choosing.

The rule behind all six

Match the size of the change to the size of the problem. Most companies on this page have a runtime and hardware problem, not an application problem — and a rewrite is a very expensive way to solve a licensing question.

The corollary matters too: if you genuinely do have an application problem, no amount of runtime engineering will fix it, and we would rather lose the deal here than six months into an assessment.

04 Option 04, in detail

Measured against the incumbent runtime. Not against our own expectations.

If you got this far and option 04 is still on your list, here is what is actually behind it. Every figure comes from differential testing against a real production corpus — both engines, same inputs, output compared.

5,079

Programs, 100% parse rate

A real production corpus, not a benchmark suite. Every program parsed. None set aside.

536,000

Lines of Business Basic source

Forty years of accumulated business rules, read by our front end without a single exception.

1.34M

Records verified byte-exact

1,344,450 records in a customer master, read on both engines and compared record for record. Not sampled.

245/245

Arithmetic cases matching

Penny-exact decimals, including the PRECISION rounding model. This is financial software; the pennies have to match.

2ms

Keyed lookup on that same file

Native SQL over the ERP's own keyed files, using their key indexes — against 3,665 ms for a full scan.

0%

CPU per idle session

Idle sessions cost nothing. The naive way to build this busy-loops, and that's how servers get sized wrong.

atlas-prod-01 · 80×24 · unmodified programs

Option 01 and option 04 look identical

A sales order entry screen from a distribution ERP: header, six order lines with quantities and extensions, one backordered line, and merchandise, freight, tax and order totals.

A sales order entry screen rendered by the replacement runtime.

↑This is the option 04 screenshot. It is also the option 01 screenshot. That is the entire point: the same programs, the same 80×24 screen, the same F-keys and the same muscle memory. Only the interpreter underneath changed — and the license did.

The write path is gated, not assumed

Records our engine writes are read back in the incumbent runtime and compared byte for byte — on real multi-level B-tree keyed files, not on a toy fixture. Writing is the part everyone waves through. We didn't.

Terminal behaviour was measured, not guessed

Full-screen forms, windows, colors, box drawing, the character-level field editor, F-keys, password masking — captured off the real runtime and replayed against ours. "Close enough" on a data-entry screen is a training cost.

How the runtime works, on uniquebb.com

05 Where we fall short

The reasons option 04 loses rows.

Every weakness in the comparison table traces back to one of these. This is pre-GA software and this is the current list, in the same words we use internally. If one of them is load-bearing for you, the free report finds it before you have signed anything.

Being rewritten

The report writer and print spooling

We're rebuilding this subsystem rather than emulating it. Emulating a forty-year-old spooler faithfully would mean inheriting its constraints forever, and printing is the one area where customers actively want the behaviour to change. It is not finished — which is why option 04 loses the retraining row.

Partial

SQL: no joins or aggregates yet

Today it is single-table SELECT with key-aware access — which is exactly what makes the 2 ms lookup possible. Joins and aggregate functions are on the roadmap, not in the build. If your reporting depends on them today, you keep your current tooling for now.

Needs source

Vendor-encrypted third-party programs

A small number of programs in a typical corpus were shipped encrypted by a third party. We can't run what we can't read. Those need source from whoever wrote them, or they need replacing — and the report tells you precisely which ones, and how many.

Landing now

The multi-user daemon

The shared-process architecture is being merged as we write this. Today a session is still a process. It works, and it is already cheap at idle, but the density story we're selling is not fully in the build yet.

By design

Cloud only — there is no on-premises build

You buy a hosted service, not software to install. One delivery model means one thing to secure and one thing to keep correct, and every customer runs the same verified build. The trade is real and we won't dress it up: you cannot run this engine on your own hardware. Your programs and your files, however, remain yours in native format and come back on request.

Pre-GA

We're taking design partners, not self-serve traffic

You will be deploying pre-GA software with a mirror running alongside it for as long as you want one, from a small team with no twenty-four-hour support desk behind it. In exchange you get direct access to the engineers building the runtime and a say in which of the gaps above closes first.

None of this is buried in an appendix, and none of it is new information three meetings in. If your corpus leans on something on this list, it will be in your report in plain language — and you can walk away having learned something useful about your own system.

Full compatibility detail, on uniquebb.com

06 Questions

The ones this page gets asked.

Q1Why would a vendor publish a table it loses rows on?

Because you were going to find out anyway, and finding out later is worse for us than telling you now. Our buyer is a CFO or an IT director who has been pitched by consultancies for a decade and can spot a rigged table from across the room. A comparison we win outright would be read as marketing and discarded in about ninety seconds.

There is a practical reason too. The rows we lose are the same weaknesses we would have to disclose in an assessment, so disclosing them here saves both sides a quarter. If option 01 or option 02 is right for you, we would rather you knew on this page than after we had both spent money.

Q2Isn't "do nothing" just the null option?

No, and treating it that way is how vendors lose credibility. Doing nothing has the lowest up-front cost, the lowest execution risk this year, zero disruption, and it changes nothing your people have to learn. That is four genuine wins, and it is more than we get.

What it doesn't do is improve. It postpones, and the price of postponing is paid later and by someone who may not be you. For a company with healthy hardware and a small license bill, another two years of postponing can be entirely correct. For a company running an eleven-year-old box with no tested restore, it isn't a decision at all — it's a bet on the hardware, placed by default.

Q3Is replacing the runtime legal?

Yes. Business Basic is a published language, and ours is a clean-room implementation of it — written from the language definition and from measured behaviour, not from anybody else's source code. It is not a fork, a patch, or a crack of an existing product.

Your programs are your programs and your data is your data. You wrote them, you own them, and running them on a different interpreter does not change that. Our terms say so in operative language rather than marketing language.

Q4You're pre-GA. Why would I bet the company on that?

You wouldn't, and we would not ask you to. The architecture is what makes the risk survivable: we do not change your programs and we do not change your data files. Your existing system keeps working on exactly the same bytes, and it keeps sitting there while a mirror of your ERP runs in parallel for as long as you want one — most people want at least one clean month-end close diffed before they will discuss a date.

The worst case is that you go back to what you had. Expensive and annoying, not fatal. That reversibility is a design decision, not an accident — and the company behind it has been trading since 1947 and runs its own warehouse on this engine.

Q5What does the free compatibility report actually tell me?

You send a tarball of your source. Our parser runs the entire corpus automatically and hands back what parsed, what didn't, which programs are vendor-encrypted and would need source, and which language features your code leans on that we have not finished. No call, no salesperson, no obligation.

It is worth having under all four options. If you are staying put, it is a documented inventory of what you are standing on. If you are rewriting, it is a free machine-generated list of exactly what has to be re-derived — which every RFP needs and almost nobody has. If you are lifting and shifting, it flags what is fragile. And if you are considering us, it is the honest starting point.

Zero-risk next step

Whichever option you lean toward, start with the inventory.

The free compatibility report is automated and costs nothing. Upload a tarball of your source and it tells you what runs, what doesn't, and which programs would need attention. It is useful under all four options — including the three that aren't us.

Get your free compatibility report See the pricing

or email us

There is no server behind this form. The button opens a pre-filled message in your own mail client, addressed to hello@uniquebb.com — nothing is sent anywhere until you press send yourself.