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 thirteen 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 every row about year three.

Doing nothing wins the rows about this week.
That split is the whole decision, and the table is left exactly as the rows fall. Published by Unique Photo · Fairfield, New Jersey · est. 1947.

  • Option 01

    Do nothing

    Renew the license. Keep the server. Keep the 2 GB file ceiling.

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

  • 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 keyed files unmodified. The runtime beneath them is replaced.

    Up-front
    Assessment, credited
    Ongoing
    $125 / user / mo
    In 3 years
    No box, one invoice

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.

There is also a date on this one that most people have not been shown. The runtime you license today cannot open a single data file larger than 2 GB. It is not a performance cliff, it is a wall: the file fails on the first read. A 2.9 GB order-detail file exists in production right now that it will not open at all. Every workaround has the same shape — archive it, split it by year, park the history somewhere else — and every one of them puts a seam through your own records that somebody has to explain to an auditor later. Doing nothing is the only option on this page with a scheduled failure date, and your order detail grows every night you trade.

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.
  • The 2 GB file ceiling arrives on a schedule set by your own order volume, not by you.

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 2 GB file ceiling moves with the runtime. New address, same wall.
  • 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 run unmodified, byte for byte. The runtime underneath them is replaced, and it arrives with the cloud it runs on.

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 runtime. We wrote a clean-room Business Basic runtime — from the published language definition and from measured behavior, not from anyone else's source — and we deliver it as the complete replacement: engine, hosting, backups, disaster recovery and a browser terminal, on one invoice. Your source runs as it sits. Your keyed data files stay in their native format with their existing keys. Nothing is rewritten, nothing is converted, no schema is declared and no data is migrated.

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. That is also why it is measured rather than promised: 5,079 programs and 536,000 lines parsed at 100%, and 3,631,827 records read on both engines and compared byte for byte across ten production files.

The engine underneath all of that was rewritten in Rust, and that is why the invoice can look the way it does. It is 3.4 MB, self-contained, with five third-party dependencies and no virtual machine beneath it. Our previous engine ran on Java and needed roughly 306 MB with its virtual machine, so the new one is about 90 times smaller. It starts in 2.41 ms rather than 56.88 ms, and it runs 13–34% faster across seven benchmark programs with byte-identical output on all seven, both engines at default configuration on the same workload. For you the point is cost: an engine that small is cheap for us to operate, so hosting, backups and disaster recovery sit inside the price instead of being metered beside it.

It also removes a wall you are already walking toward. The runtime you license today cannot open a single data file larger than 2 GB, and a 2.9 GB order-detail file exists in production right now that fails on the first read. Ours has no such ceiling: file size is bounded by the disk rather than by the runtime, so files scale into terabytes with nothing archived, nothing split and nothing to explain to an auditor. The price is published, the assessment is credited in full against the migration, and the system you have today runs in parallel the whole way through and is still standing the day after cutover.

Genuinely in its favour

  • Programs run unmodified, byte for byte. Not ported, not converted, not "mostly compatible".
  • Keyed data files stay in native format with their existing keys. Nothing is re-encoded.
  • No 2 GB ceiling. File size is bounded by the disk, so files scale into terabytes.
  • One invoice: engine, hosting, backups, disaster recovery and a browser terminal.
  • Five third-party dependencies in the whole engine, and no virtual machine beneath it to patch, audit or license separately.
  • 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.

What it actually costs

  • $125 per named user per month on Managed Cloud, minimum ten users. $195 on Private Cloud, minimum twenty-five.
  • A $9,500 assessment before the migration — credited back in full against it.
  • Printing changes: the report writer and spooler are rebuilt, not emulated.
  • Reporting is engineered against your corpus. The assessment inventories every report and print path you run and sets the build order.
  • Every integration and third-party component is inventoried up front, with what each one needs, before anything is committed.
  • Delivered as a running system rather than software to install — one verified build, one invoice, no hardware.

Right for you if

The application still fits the business, and every problem is underneath it — the license, the box, the ceiling, the shrinking bench. That is most of this market, and it is a precise description of the company we were when we started writing this. If your reporting and your printing are heavily customized and load-bearing, that is the normal case rather than the exception — both are engineered against your corpus by the engineers who wrote the engine, and the assessment inventories every report, print path, integration and third-party component you run before anything is committed.

02 Side by side

Thirteen 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. Doing nothing wins five rows. So do we. The part worth your attention is which five, because the two sets do not overlap by a single row.

Scroll the table sideways →

Four options for a Business Basic system compared across thirteen 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 $9,500 assessment — credited in full against the migration, so it nets to nothing the moment you proceed.
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. $125 per user / monthWins this row.Published list, minimum ten users, annual billing two months free — engine, hosting, backups, disaster recovery and browser terminal all inside that number. Hosting can sit inside it because the engine is 3.4 MB and uses 14–21x less memory than the Java engine we ran before it on the same workload. And you never pay more than half your current runtime license: if half your invoice is below list, you pay the half.
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. Low, and reversibleYour corpus is parsed and your files are read before anything is quoted, your system runs in parallel until you are satisfied, and the one you have today is still standing the day after cutover.
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 — they run as they sitPrograms run unmodified. The assessment inventories every integration and third-party component first and says what each one needs, before anything is committed.
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.
HeadroomHow large a file can get 2 GB, then it stopsThe runtime you license today cannot open a single data file above 2 GB. It is a wall, not a slope — the file fails on the first read. A 2.9 GB order-detail file already exists in production that it will not open. Solved, eventuallyA modern system has no such limit. It arrives at the end of a seven-figure multi-year programme, which is a long time to be holding a file that is already too large. 2 GB, new addressSame runtime, same ceiling. The cloud disk is bigger, but the limit lives in the interpreter rather than in the disk. Bounded by diskWins this row.No ceiling in the runtime, so files scale into terabytes with nothing archived, nothing split and no seam through your own history to explain to an auditor. Largest single file verified byte-exact: 1,704,372 records.
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 of the fourWins this row.Nothing is converted or re-encoded; programs and files stay yours in native format and come back on request. We deliver a running system on one invoice, so what you would be leaving is a subscription, not a data model.
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. That is what a mass-market product buys you, and it is a genuine advantage. Three different numbersCloud provider for the machine, runtime vendor for the license, your own person for the application. Expect to referee. Us — the people who wrote itYou reach the engineers who built the engine, not a script. We are paged when our own warehouse stops, which is usually the same page.
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. One invoice, no box, no ceilingWins this row.Programs unchanged, keyed files unchanged, hardware gone, and the runtime on a published rate you can put in a budget. The file that would have stopped you never does.

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

  • 5/13

    Do nothing

    Every row it wins is about this week. Every row it loses is about every week after.

  • 1/13

    Rewrite

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

  • 2/13

    Lift and shift

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

  • 5/13

    Move the runtime

    Level on count. Our five are the ones with money, data and dates attached.

How to read the tally

Doing nothing wins five rows and so do we. The count is level. The rows are not remotely comparable.

Every row doing nothing wins is about this week: what it costs now, what it disrupts now, what nobody has to learn now. Every row we win is about money, data and dates — the invoice, the files, the dependency, the 2 GB ceiling, and where you are standing in three years. Doing nothing is not a strategy that wins. It is a strategy that postpones, and one of the things it now postpones has a delivery date set by your own order volume rather than by you.

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

Four options, and the one that fits depends on about seven 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

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

Read down until one of these describes your company. If two of them do, the one with a date attached wins — a deadline beats a preference every time.

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

A data file has already passed 2 GB, or your order detail is heading there — and somebody has started talking about archiving history to buy room.

Then

Move the runtime. Option 04, and there is a clock on it.

This is the row where three of the four options do the same thing: nothing. The ceiling belongs to the interpreter, so renewing keeps it and moving the machine carries it with you, and a rewrite fixes it years after the file stopped opening. Ours has no ceiling — file size is bounded by the disk — so the history stays in one file with no seam for anyone to ask about later.

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 case we built for, and it is a precise description of the company we were when we started. Programs unchanged, keyed files unchanged, $125 per named user per month with hosting, backups, disaster recovery and the browser terminal inside it — and the old system still sitting there while a mirror proves the new one.

If

Your reporting and your printing are heavily customized, and the business genuinely leans on both of them.

Then

Then it gets built to your corpus. That is the method.

Reporting and printing are where corpora differ most, so yours are engineered against your corpus rather than assembled from a feature list. The free report inventories every query and every print path your business actually leans on, the assessment says what each one needs, and that is what gets built for your migration — by the engineers who wrote the engine, not by a partner network. Custom work is the model here, not an exception, and it is why the assessment comes first.

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

Proven against the runtime you already pay for.

Option 04 is the only one that does not ask you to pay twice or start over. Here is what is behind it. The correctness figures come from differential testing against a real production corpus — 50 GB of live ERP data, both engines, same inputs, output compared value by value. The engine figure beside them is measured on the binary itself, at default configuration.

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.

3.63M

Records verified byte-exact

3,631,827 records across ten production files, 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, 1,344,450 records

Native SQL over the ERP's own keyed files, using their key indexes — against 3,665 ms to scan the same customer master end to end.

3.4MB

The engine, whole

One self-contained native binary with five third-party dependencies, against roughly 306 MB for our previous Java engine and its virtual machine. Cheap to operate is why hosting sits inside the price.

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 ceiling nobody mentions

The runtime you license today cannot open a single data file larger than 2 GB. It is not a performance cliff, it is a wall: the file fails on the first read. A 2.9 GB order-detail file exists in production right now that it will not open at all.

Every workaround has the same shape — archive it, split it by year, park the history somewhere else — and every one of them puts a seam through your own records that somebody has to explain to an auditor later. Our engine has no such ceiling. File size is bounded by the disk rather than by the runtime, so these files scale into terabytes with nothing archived, nothing split and nothing to explain. The largest single file we have verified byte-exact holds 1,704,372 records, and it was nowhere near a limit. The corpus behind every number on this page is 50 GB of live ERP data: 1,344,450 customers, 1,541,007 order lines, 93,301 items.

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 behavior 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 Pricing

Published, per named user, with nothing underneath it.

One invoice covers the runtime, the hosting, the backups, the disaster recovery and the browser terminal. There is no infrastructure line, no storage meter and no per-report charge, because the entire point of option 04 is that you stop buying the pieces separately and stop owning the hardware they sit on.

$9,500

Full assessment, one-time

Your corpus parsed, your files read, your printing and reporting sized against the real thing. Credited in full against the migration, so it nets to nothing if you proceed.

$125/mo

Managed Cloud · per named user, minimum 10

Billed in the same unit you already buy seats in. Engine, hosting, backups, disaster recovery and browser terminal included, never metered, never an upsell.

$195/mo

Private Cloud · per named user, minimum 25

Dedicated rather than shared infrastructure, for companies whose auditors or customers require it. Same engine, same inclusions, same invoice.

The half promise, now a guarantee on top of list

You will never pay more than half the runtime license you pay today. If half your current invoice comes out below list, you pay the half — so you cannot end up worse off by moving.

Annual billing is two months free. A twenty-five-seat shop on Managed Cloud is $3,125 a month, or $31,250 a year billed annually — and that figure already contains the hosting, the backups, the disaster recovery and the hardware refresh you were otherwise going to have to fund on your own.

Before any of that

The compatibility report is free and automated

Send a tarball of your source. You get back a full inventory of your corpus — every program, every integration, every third-party component, what each one needs, and which language features your code leans on. No call, no salesperson, no obligation — and it is useful under all four options.

Get the free report

06 Scope

What stays the same, what changes, and what we build to your corpus.

Custom work is the method here, not an exception. Every migration is engineered against the customer's own corpus by the engineers who wrote the engine. This is what stays untouched, what gets rebuilt, and what gets engineered to yours — and the free report tells you which of these actually touch your system, before any money moves.

Unchanged

Your programs and your keyed data files

Source runs as it sits, byte for byte — not ported, not converted, not "mostly compatible". Files keep their native format and their existing keys: no schema declared, no data migrated, nothing re-encoded. 5,079 programs and 536,000 lines parsed at 100%, and 3,631,827 records read on both engines and compared record for record across ten production files.

No ceiling

File size is bounded by disk, not by the runtime

The runtime you license today stops at 2 GB per file — a wall rather than a slope, and a 2.9 GB order-detail file already exists in production that it will not open. Ours has no such limit, so files scale into terabytes with nothing archived, nothing split and no seam through your own history for an auditor to ask about. Largest single file verified byte-exact: 1,704,372 records.

Rebuilt

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 behavior to change. It is also the one thing on the screen your people will notice, which is why the assessment begins by inventorying every print path your business actually leans on.

Your corpus

SQL and reporting

Native SELECT runs straight against the ERP's own keyed files, key-index aware — which is exactly what makes a 2 ms lookup against 1,344,450 records possible where a full scan takes 3,665 ms. Reporting corpora differ wildly between companies, so yours is engineered against your corpus rather than against a feature list: the assessment inventories every report you run, says what each one needs, and sets the build order.

Inventoried

Every integration and third-party component

The assessment inventories all of it — every interface, every bolt-on, every component somebody else wrote — and says what each one needs, before anything is committed. The free report names them and counts them, so nothing is discovered three meetings in and nothing is quoted before it has been looked at.

By design

Managed cloud — you buy a running system

Engine, hosting, backups, disaster recovery and browser terminal on one invoice, rather than software to install and then own. One delivery model means one thing to secure and one thing to keep correct, and every customer runs the same verified build — the one our own warehouse ships on. Your programs and your files remain yours in native format and come back on request.

None of this is buried in an appendix and none of it turns up three meetings in. If your corpus leans on something on this list it will be in your report, in plain language, before you have signed anything — and you walk away having learned something useful about your own system either way.

Full compatibility detail, on uniquebb.com

07 Questions

The ones this page gets asked.

Q1Why would a vendor publish a table it doesn't sweep?

Because you were going to work it out anyway, and working it 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 won outright would be read as marketing and discarded in about ninety seconds.

There is a practical reason too. The rows we don't win are exactly what we would have to put in front of you during an assessment, so putting 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 five genuine wins — precisely as many as 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. And there is now a second clock running beside the hardware one: the runtime cannot open a data file above 2 GB, and a 2.9 GB order-detail file already exists in production that fails on the first read.

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 behavior, 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.

Q4What happens if the move doesn't work out?

You go back to what you had, and the way back is short because nothing was converted. We do not change your programs and we do not change your keyed data files, so the system you run today keeps working on exactly the same bytes. It sits there untouched 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 value by value before they will discuss a date.

Every step before that is reversible too. The compatibility report is free. The $9,500 assessment is credited in full against the migration. Your current system is still standing the day after cutover. That reversibility is a design decision rather than 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 a complete inventory — every program, every integration, every third-party component, what each one needs, and exactly which language features your code leans on. 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.

Q6What does it cost, and what is inside the price?

Managed Cloud is $125 per named user per month with a minimum of ten users. Private Cloud, on dedicated infrastructure, is $195 with a minimum of twenty-five. Annual billing is two months free, which puts a twenty-five-seat shop at $3,125 a month or $31,250 a year. The engine, the hosting, the backups, the disaster recovery and the browser terminal are all inside that number and never appear as line items.

On top of list there is a guarantee: you will never pay more than half the runtime license you pay today. If half your current invoice is below list, you pay the half, so moving cannot leave you worse off than staying. The only other figure on the page is the $9,500 assessment, and that is credited back in full against the migration.

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 inventories what you are standing on: every program, every integration, every third-party component, and what each one needs. 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

Leave an email and a person will write back. Want to tell us more first? Use the signup form, or write to hello@uniquebb.com.