A Performis white paper — September 2026
Executive Summary
The problem. Enterprise software has quietly built its entire economics around a single mechanism: charge for who is allowed to log in, not for what actually gets done once they do. A named software seat costs the same whether the person behind it uses it eight hours a day, twenty minutes a week, or has left the company and nobody's gotten around to deprovisioning the account. Independent research, none of it commissioned by a vendor with a stake in the answer, puts the resulting waste at tens of millions of dollars a year at the average large organization -- and that's before counting the customization and integration fees that stack on top of the license every year after. Syspro's 2026 decision to end perpetual licensing for roughly 15,000 manufacturing customers worldwide is the most visible recent instance of this pattern, not an isolated one: SAP, Oracle, Microsoft, and Sage have each run a version of the same play in just the last three years -- a licensing-metric change, an indirect-access claim, a forced subscription migration, a new fee stacked on an old one -- and the mechanism underneath every one of them is identical, even where the specific tactic differs.
Our fix. Performis doesn't compete by offering a better rate on the same relationship. We start from a different premise entirely: agents should execute the operational work directly -- profiling a system's data, proposing how it maps onto a new one, extracting the business rules buried in old scripts, generating the code that moves the data, and running the reconciliation checks that prove it moved correctly -- and a person should only be pulled in for the decisions that are genuinely decisions: confirming a mapping an agent can't be certain about, signing off before a system goes live, approving something material enough that it should have a name attached to the approval. This isn't a roadmap item or a pitch-deck diagram. It's the operating model already running today across three separate engagements in three separate industries -- legal, healthcare, and manufacturing -- each with agents and humans doing exactly this division of labor.
Our edge. The rest of the software industry is only now arriving at the conclusion that charging for outcomes beats charging for access. Salesforce, Intercom, and Sierra have each walked away from per-seat pricing on their AI products within the last eighteen months, and analysts at a16z, IDC, and Bain are all independently describing the same shift. Performis got here first, and not by accident: outcome-based pricing only makes sense once there's a real outcome being produced by something other than the customer's own labor. A support ticket resolved by an AI agent is a real, meterable event. A dashboard the customer still has to open, read, and act on themselves is not -- no matter what the pricing page calls it.
Part 1: The tax nobody named until now
Call it what it actually is. A tech tax is what a business pays when a piece of software's cost scales with how many people are permitted to access it, entirely independent of how much value that access produces on any given day. It is, by design, disconnected from outcomes -- which is exactly why Syspro's own installed base makes such a clean case study of the pattern. Performis has already published a detailed breakdown of what Syspro's 2026 licensing notice actually says and what it costs a typical shift-based manufacturer -- see Your SYSPRO Renewal Isn't a Price Increase -- It's a Tech Tax -- along with a free Syspro Renewal Exposure Calculator that estimates a plant's real named-user exposure from its concurrent licenses and shift pattern in under a minute. What follows here is the broader pattern that Syspro's notice happens to make unusually visible for one industry, in one quarter -- not a phenomenon unique to one ERP vendor.
The tax shows up in two layers, and both are real, sourced, and larger than most finance teams assume when they first hear the argument.
Layer one: seats you're paying for and not using
This is not a new problem, and it did not start with Syspro. It has been measured, independently and repeatedly, by research firms whose business model depends on getting the number right, not on flattering a vendor.
- Zylo's SaaS Management Index, built from real telemetry across more than 40 million licenses and $40 billion-plus in tracked spend, found that the average organization wastes $19.8-21 million a year on SaaS licenses nobody is using, running at only about 54% utilization of what's actually been purchased across the 2025 and 2026 editions of the report. That waste isn't evenly distributed either -- it scales sharply with company size, from roughly $3.8 million a year at organizations under 500 employees to more than $80 million a year at the largest enterprises, and Zylo's own per-employee figure (north of $4,800 in annual SaaS spend per head) makes clear this isn't a rounding error hiding in a footnote of the IT budget; it's a structural line item most finance teams have simply stopped interrogating.
- Gartner's landmark CRM licensing study found that 42% of purchased CRM licenses went completely unused, representing over a billion dollars in waste against a roughly $3 billion market at the time the study ran. The study itself is decades old now, but the mechanism it documented -- seat-based CRM pricing charging in full for access nobody exercises -- hasn't gone anywhere. If anything, the category has only grown larger and more entrenched in the years since.
- Flexera's State of ITAM research puts wasted spend at roughly a third of the total IT estate, consistently, across desktop software, data-center software, and SaaS alike. The consistency across categories is the point: this isn't a SaaS-specific quirk or a symptom of cloud migration moving too fast. It's what happens whenever software is priced on access rather than use, regardless of where that software actually runs.
None of this reflects incompetent IT departments failing to manage their license estates. It's the predictable, structural output of a pricing model that was designed to charge for access granted, not for value delivered -- and a named seat, by construction, cannot tell the difference between someone using it productively all day and someone who logged in once, months ago, and never came back. Add up what a business actually pays across a single renewal cycle -- the vendor for the license, the systems integrator for the customization work, the platform itself simply for continuing to exist -- and it's worth asking plainly: paying for what, exactly? The vendor controls what happens next, not the customer, and that control is the actual product being sold, whether or not it's the one named on the invoice.
Layer two: the customization tax that compounds every year after
The license fee is only the entry ticket. What most cost analyses of enterprise software miss entirely is the second, larger, recurring bill sitting directly behind it. Panorama Consulting's independent ERP research -- one of the few research bodies that tracks ERP total cost of ownership without a vendor relationship to protect -- finds that professional services spend (implementation, customization, integration work) typically runs 100-200% of the annual license fee, on top of the license itself. That figure isn't a one-time cost paid at go-live and then forgotten; it repeats every time a business process changes, a new module gets bolted on, or a version upgrade forces existing customizations to be rebuilt from scratch. Panorama's own manufacturing-specific survey found that only 7% of ERP customers run their system "as-is" out of the box -- the other 93% customize to some degree, and every one of those customizations is a small, recurring toll charged by whoever controls the underlying platform, whether that toll shows up as a professional-services invoice, a module license, or a "certified partner" day rate.
This isn't just an incidental cost, either -- it's recognized as valuable enough that private equity has begun consolidating the implementation-partner layer itself, acquiring ERP and EPM consultancies specifically for their ability to customize a platform and deepen a client's dependence on it. A firm that customizes a system more thoroughly doesn't just bill more hours for the work; it makes the client harder to leave, and that stickiness is now a real, financially exploited business model in its own right, not merely an unfortunate byproduct of technical debt. The implementer isn't a neutral party helping a customer get more out of their software -- in a real and growing number of cases, deepening the customer's dependence on that specific platform is the actual investment thesis.
This is the deeper reason Syspro's licensing notice matters well beyond Syspro's own installed base. A concurrent-to-named licensing change is one visible, sudden mechanism for extracting more revenue from an existing customer base. Customization fees, module upsells, and integration costs are quieter, steadier versions of the same extraction, spread out so they never trigger the kind of attention a single formal notice does. Both are symptoms of the same root cause:
The vendor is paid for the platform existing, not for the outcome it produces.
The same playbook, five times over
Syspro isn't an outlier, and it isn't the first time this has happened this decade. It's the latest instance of a pattern that's run, in slightly different form, at nearly every major enterprise software vendor in recent memory. The specific mechanism differs from vendor to vendor -- that difference matters, and it's worth being precise about it rather than flattening four distinct playbooks into one -- but the underlying category of behavior is identical every time: monetize access by counting people, then redefine what counts as a person, a seat, or a user exactly when it's time to grow revenue from a customer base that hasn't changed what it actually does with the software.
SAP built an entire body of contract law around this specific move. In 2017, the UK High Court ruled against Diageo in a dispute over "indirect access" -- SAP's position that when a Salesforce integration fed data into Diageo's SAP system, everyone touching that integration, not just people logging into SAP directly, counted as a licensable named user. Diageo's reported exposure ran past £54 million, for usage that hadn't changed at all; only SAP's definition of who counted as a "user" had. Anheuser-Busch InBev faced a similar claim reportedly seeking more than $600 million before it was settled confidentially. The complexity hasn't eased since: in 2025, SAP retired its "RISE Premium" cloud tier for a new structure that Info-Tech Research Group's Scott Bickley called a "stealth price increase" in industry coverage, describing the customer experience in a line that could serve as this paper's epigraph: "SAP licensing feels like a world where the rug is constantly being pulled from under one's feet."
Oracle runs a quieter version of the same play, with a different mechanic. Oracle's Named User Plus licensing requires a minimum of 25 licenses per processor, regardless of how many people actually touch the system -- a tax floor that exists independent of real usage. In January 2023, Oracle went further with Java SE specifically, replacing per-user licensing with an "Employee" metric that counts a company's entire headcount, whether or not most employees ever open Java. Reported bill increases ran as high as 30x for some customers, with 2-5x being the more typical range -- and by 2025, industry surveys found roughly 90% of Oracle Java customers actively evaluating a move to open-source alternatives.
Microsoft takes the quietest approach of the four: stacking, not redefining. Microsoft 365 Copilot launched in 2023 at $30 per user per month -- not instead of an existing per-seat subscription, but layered directly on top of one a customer was already paying. The tax doesn't get restructured. It just accumulates.
Sage offers the closest real precedent to Syspro's own 2026 move, structurally. Sage stopped selling new perpetual licenses for Sage 50 at the start of 2023, using a security justification -- deprecating older encryption protocols on a fixed deadline -- to functionally force long-standing perpetual customers onto subscription pricing whether they wanted the move or not. The trade press ran a multi-part investigation into the backlash, including one customer's account of losing a fifteen-year license with a decade of value still on the table, calling the vendor's compensation offer "insulting."
Four different vendors, four different specific mechanisms -- an indirect-access legal doctrine, an employee-count metric, fee-stacking, a forced perpetual-to-subscription conversion -- and the same underlying category of behavior every time. It's worth being direct about what this pattern doesn't prove: these vendors don't run identical playbooks, and a buyer who has actually negotiated a SAP or an Oracle contract will rightly object to having their hard-won, vendor-specific knowledge flattened into someone else's story. What the pattern does prove is that this was never a Syspro problem, or even an ERP-specific one. It's what happens, reliably, whenever a vendor controls the mechanism its customer's cost is metered against.
The discount trap -- and why your leverage disappears exactly when you need it most
Here's the part of the pattern that never makes it into a sales deck, because it isn't in the vendor's interest to say it out loud: the discount that got you into the relationship was never a favor. It was the opening move in a negotiation that ends years later, on the vendor's terms, not yours.
It plays out in almost the same shape across every vendor named above. A prospective customer gets a steep discount, a waived implementation fee, or a generous multi-year rate to sign in the first place -- a real, rational trade for the vendor to make, since the value of a locked-in account justifies the cost of winning one. Syspro's own notice runs a version of this explicitly, crediting prior license payments toward the new subscription and "encouraging early conversion for maximum value" -- a discount, dressed as a courtesy, with a deadline attached to make sure it's taken. Once the deal is signed, the real work of the relationship begins: data gets loaded, processes get built around the system's specific quirks, integrations get wired to its API, and employees learn workflows that exist nowhere else. None of that effort is wasted -- it's exactly what a working system should produce. But every hour of it is also a small, permanent increase in switching cost, and switching cost is the only thing standing between a customer and whatever the vendor eventually decides to charge.
By the time the renewal conversation actually happens, the two sides are no longer negotiating as equals, and both of them know it. The vendor has watched thousands of other customers run the exact same calculation and has a high-confidence estimate of precisely how expensive it would be for you to leave. The customer, meanwhile, is often doing that math for the first time, on a deadline, with a system too deeply embedded to actually replace before the renewal date arrives. That asymmetry isn't an accident of one bad negotiation -- it's the entire commercial logic of the model: discount going in, because a locked-in account is worth the cost of winning it; extract going out, because the customer's leverage was already spent on the very success of the implementation. SAP's 2025 restructuring, Sage's forced migration, and Syspro's own 2026 notice are three different vendors running the same script at three different moments -- and the tax always arrives precisely when the customer is least able to say no to it.
Part 2: The real fix -- agents that do the work, not software you configure to do it
A different price on the same underlying relationship doesn't fix a tech tax. It just changes its shape -- a usage fee charged for logging into a dashboard is, functionally, a differently-shaped seat tax, because the customer is still the one doing the work; only the billing mechanic has changed. The actual fix has to sit upstream of pricing entirely: agents that execute the operational work directly, rather than a platform that a customer's own people have to staff, configure, and operate regardless of what it actually produces that quarter.
Stated specifically, rather than as a slogan, this is the mechanism: what agents do directly, today, without a human doing it first -- schema and data profiling against a customer's actual, live system; candidate mapping proposals, each carrying a confidence score, when data needs to move from one system's model to another's; business-rule extraction from existing scripts and stored procedures that nobody currently understands well enough to document by hand; transformation-code generation; and full-dataset reconciliation diffs, run continuously against production rather than checked once at go-live and assumed correct forever after. In an ongoing operational deployment, this same pattern extends to standing diagnostic work -- reading a business's live data on a schedule and surfacing findings automatically, the way a good analyst would if one were watching the numbers every single day instead of once a month.
What stays deliberately human, and why, is just as specific. Ratifying a semantic mapping between two systems' data models is a judgment call, not a computation -- an agent can propose with high confidence that one system's "Customer Status" field corresponds to another's "Account Type," but only a person with real domain context can confirm that the mapping doesn't quietly break an edge case the agent has no way of knowing matters (a status value that means something different for one specific customer segment, say, for reasons buried in a decade of institutional history no schema documents). Signing off a system cutover, approving a recommendation large enough to matter, and owning the actual client relationship sit in the same category: agents are genuinely strong at compressing what would be hours of manual excavation into a decision a person can review in seconds, but that's a claim about surfacing a decision-ready option quickly, not a claim about removing the judgment itself. This is a deliberate, named boundary rather than a hedge, and it's the honest answer to the obvious challenge anyone should ask when a vendor says "our platform is really a team": if something goes wrong, who's actually accountable, and for what specifically? The answer here is a named list of human responsibilities, not an assertion that the team is "mostly agentic" and therefore doesn't need one.
It's also worth being direct about what this claim is not, since the honest version of this pitch is more credible than a cleaner-sounding one. This is not a claim that implementation, migration, hosting, and ongoing support become free -- they don't, and a real system migration carries real cost and genuine risk: data-conversion errors and reconciliation failures at cutover are a named, serious risk in any migration, not a footnote to wave past. The accurate way to state the economics is this: Performis replaces a seat tax with a smaller, front-loaded implementation cost, followed by ongoing pricing tied to usage -- not a claim of "near-$0" total cost, and not a rip-and-replace of a customer's entire technology stack. What actually changes is which costs are real and which are artificial. The cost of migrating and operating a system honestly reflects the work involved in doing that migration and operation well. The cost of a named-user tax, by contrast, reflects nothing but headcount -- whether or not that headcount is creating any value for the business on the day it's being billed for.
Proven across three verticals, not one
None of this is a plan for some future engagement. It's the live operating model behind three real, currently running engagements, in three genuinely different industries, each independently arriving at the same division of labor:
- A multi-office litigation practice. Agents read incoming case filings and derive the jurisdiction-specific procedural rules that determine deadlines and required filings automatically, across courts with meaningfully different rule sets. A person ratifies the genuinely ambiguous edge cases and signs off before anything reaches a firm calendar or a client-facing deadline -- because a missed procedural deadline in litigation isn't a minor error, it's a malpractice exposure.
- A payer-contracting system in healthcare. Agents extract and structure contract terms and negotiated rate data out of payer agreements at a volume and consistency no human team reviews manually -- the kind of document-heavy, detail-dense work that used to consume analyst-hours by the week. A person ratifies the final negotiating position before it's ever used in an actual conversation with a payer, because that's a business decision with real financial consequences, not a data-extraction task.
- A discrete manufacturer running Syspro ERP. Agents profile the ERP's schema and monitor operational risk -- cycle-time deviation, capacity constraints -- continuously rather than on a reporting cadence. A person ratifies every data-migration mapping and signs off the system cutover itself, the same boundary described above, applied to a live manufacturing environment.
Three different industries, three structurally different workflows, and the same division of labor holding in every one of them: agents doing the specific, named technical work; humans making the specific, named judgment calls. That consistency across unrelated domains is itself evidence this is a real operating model, not a framing applied after the fact to whatever happened to get built.
Part 3: The market is already moving here -- Performis got there first
None of the argument in Part 2 depends on taking Performis's word for it that agentic execution changes what's fair to charge for. The wider software market -- including companies with every commercial incentive to defend the per-seat model that built their existing revenue -- is independently arriving at the same conclusion, and arriving there recently enough that the shift is still genuinely newsworthy rather than settled history.
Salesforce, arguably the company most responsible for popularizing modern per-seat SaaS pricing in the first place, launched its Agentforce AI product in late 2024 priced per conversation, then revised that model to Flex Credits sold in bulk, and has since moved again to pure outcome-based pricing: $2 per resolved case, with an explicit rule built into the pricing that a case escalated to a human being isn't billed at all. That's three pricing iterations in under two years from the company that arguably wrote the per-seat SaaS playbook everyone else copied -- a fast, public admission that the old model doesn't fit an AI-agent product.
Intercom's Fin charges $0.99 per resolved outcome, and -- notably -- is explicitly marketed as capable of running on top of a competitor's seat-priced helpdesk platform "with no seats required" from Intercom's own side, which is as direct a statement as a vendor can make that seats and outcomes are now understood as two separate, competing units of value in the same market.
Sierra, the AI customer-agent company founded by Bret Taylor -- Salesforce's own former co-CEO -- states its positioning publicly and without much hedging: legacy customer-experience vendors are "trapped in seat-based revenue models" that actively work against deploying effective AI agents, and outcome-based pricing "eliminates shelfware" by construction, since there's no such thing as an unused outcome the way there's an unused seat. It's a notable detail that the person making this argument most publicly used to run the company most associated with the model he's now arguing against.
Even inside ERP specifically -- the exact category this paper opened with -- Acumatica has built genuine, durable market share on unlimited-user, consumption-based pricing rather than per-seat or per-named-user licensing, proving a usage-priced alternative to concurrent or named-user ERP licensing is a viable, currently-competing commercial model today, not a theoretical future one.
Analysts are describing the same inflection point from outside any single vendor's incentives. a16z's enterprise newsletter argued in December 2024 that per-seat pricing is "no longer the natural atomic unit" once AI agents absorb the underlying work a seat used to represent. Industry coverage of IDC's FutureScape 2026 predictions forecasts that pure seat-based pricing will be functionally obsolete by 2028, with the majority of software vendors expected to refactor their pricing models around new value metrics -- a view echoed by Bain & Company's own framing that customers will increasingly expect to pay based on outcomes achieved, "not log-ons."
It's worth being precise about exactly what this section proves, and what it doesn't. It proves the pricing shift described in this paper is real, already underway, and being driven by sophisticated, well-capitalized companies with no reason to chase a fad -- this is not a fringe idea Performis invented to sound current. What it does not prove, on its own, is that Performis is meaningfully different from Acumatica specifically, because Acumatica already sells usage-based ERP pricing today, full stop. If "we price on usage, not seats" were the entirety of Performis's pitch, it would be a feature already shared with an established, credible competitor -- not a category difference worth a white paper. The actual difference is everything described in Part 2: unlike a pricing philosophy alone, Performis's claim is backed by a live, checkable mechanism running across three real engagements in three real industries, not a rate card that happens to be structured differently from a competitor's.
Part 4: A world without the tax
Strip the tax out entirely and picture what's actually left.
Adding a new person to a growing team doesn't trigger a conversation about whether there's a spare license, which tier of "user" they should be provisioned as, or whether the budget can absorb one more seat this quarter -- access was never the thing being charged for, so it simply isn't a constraint. A finance team stops treating its annual renewal as a bracing-for-impact exercise, because the fallback of walking away was never lost to begin with -- there's no proprietary system holding years of switching cost hostage, the way there was for Diageo, for Sage's perpetual-license holdouts, for every Syspro customer reading this year's notice. The conversation with a software provider shifts from "how many seats do we need this year" to "what did the system actually do for us this year" -- a question every vendor named in this paper would rather not have to answer in public, because it's a much harder question for a seat-metered product to answer well.
This isn't a hypothetical Performis is inventing from nothing. a16z's own December 2024 analysis makes the mechanism explicit: Zendesk currently charges roughly $115 a month per support-agent seat, regardless of how many tickets that agent actually resolves -- but once an AI agent is doing the resolving instead of a human, "the natural pricing metric becomes successful outcomes," not seats. That's precisely why AI-native companies building customer-facing agents from scratch -- Decagon, pricing by resolved conversation, among others -- are skipping seat-based pricing entirely rather than retrofitting it onto a new product.
The honest caveat, stated plainly rather than implied: none of SAP, Oracle, Microsoft, or Sage show real evidence of moving their core ERP or platform pricing in this direction yet. If anything, the pattern from Part 1 shows the opposite -- incumbents doubling down on seat- and headcount-based metering at the exact moment the rest of the software industry is visibly moving toward outcomes. That's not a weakness in this argument. It's the argument: the vendors with the most to lose from a world without the tax are, unsurprisingly, the last ones who are going to build it. Someone else has to -- which is the whole reason Part 5 exists as a real, worked example rather than a thought experiment.
Part 5: A manufacturer's full transition, start to finish
To make all of this concrete rather than abstract, here is what the pattern looks like end to end, for one manufacturer.
A Midwest-based manufacturer of vehicular lighting systems supplies five original-equipment channels -- trailer, work truck, marine, emergency, and transit -- from a single facility running Syspro ERP across more than 4,000 active part numbers, on a three-shift operating schedule.
Diagnose. When Syspro's 2026 licensing notice arrived, the plant's IT team had exactly one number to work with: a concurrent-license count on the existing invoice. Nobody had an answer for how many distinct people actually touched the system across a full day's rotation of shifts -- that number had simply never had a commercial reason to exist before. Performis's Renewal Exposure assessment, run as a read-only connection against the plant's own Syspro database, took an afternoon to produce the real figure: 52 concurrent licenses translated to just under 290 distinct named identities once every shift, every warehouse login, and roughly a dozen legacy e.net integrations were actually counted individually, the way the new subscription model would count them. At list-rate pricing, that gap represented a real exposure of roughly $390,000 a year -- more than four times what the plant had originally budgeted for the renewal.
Bridge, then migrate. Rather than negotiate against Syspro with no real number of their own, the plant used that assessment to secure a 12-month bridge term with a capped renewal uplift clause -- buying room to make a deliberate decision instead of signing a multi-year agreement under deadline pressure, which is exactly the trap a forced renewal deadline is designed to create. Over the following two quarters, a certified open-source implementation team migrated the plant's item master, bill-of-materials structure, and open work orders onto an ERPNext foundation, while Performis's reconciliation agents ran the full trial-balance, inventory-valuation, and BOM-explosion checks -- the same category of audit-grade verification described in Part 2 -- that let the plant's CFO sign off the cutover on the strength of evidence, rather than on faith in the implementation team's assurance that everything had gone correctly.
Run the agentic layer. Two agentic workflows went live alongside the new system. One tracks mold-tool cycle-time deviation against engineering standard continuously across the plant's entire press fleet, rather than surfacing deviations only when someone happens to review a monthly report. The other models work-center capacity thirty days out, specifically to flag revenue-at-risk from an emerging bottleneck before it actually causes a missed delivery, rather than after a customer has already noticed.
The results, within two quarters of running on the new platform:
- The projected $390,000 licensing exposure was eliminated entirely, replaced by a usage-priced agentic layer running at roughly a quarter of that annual cost.
- $180,000 in previously invisible lost capacity was surfaced at a single constrained press station running at 97% utilization -- caught by the capacity-monitoring agent before it caused a missed shipment, not discovered afterward in a post-mortem.
- Unplanned mold-tool downtime fell by an estimated 30%, driven by flagging cycle-time deviation as it happened rather than discovering it weeks later in a scheduled report.
What this means
A perpetual software license was never really about the software itself. It was a negotiating position -- concrete proof that a customer didn't have to accept whatever a vendor decided to charge at the next renewal, because the fallback of simply not renewing and continuing to run what they already owned was real and available. Named-user subscription pricing, layered on top of a proprietary system a customer doesn't ultimately control, removes that fallback permanently, for every customer it touches -- and Syspro's installed base is simply the clearest, most recent, most visible place to watch that removal happen in real time.
The alternative described in this paper isn't a cheaper version of the same relationship dressed up in new pricing language. It's a genuinely different one: agents that do real, specific, accountable work -- already proven, today, across legal, healthcare, and manufacturing engagements -- running on a foundation no single vendor can unilaterally re-tax at the next renewal, priced against the usage and value that work actually creates instead of against how many people happen to be logged in that month.
See where your own exposure sits first: the Syspro Renewal Exposure Calculator estimates your named-user count and annual subscription cost from your concurrent licenses and shift pattern -- free, no sign-up, in seconds. Every operation is different, and a calculator can only ever be a starting estimate -- when you want to walk through what this actually looks like for your own facility, talk to Performis directly.