The Blog
Thinking clearly about ERP.
Architecture, critique, implementation reality, and the long argument for building things right the first time.
Cash Forecasting Without a Crystal Ball: The Data Architecture Underneath
Thirteen-week cash forecasting is easy to describe and hard to do reliably. The forecast is only as good as the inputs, and most companies are building it from a disconnected AR aging report, a disconnected AP schedule, payroll data from a separate system, and whatever assumptions the controller has embedded in the Excel model. The quality of the forecast is entirely a function of the quality of the underlying data architecture.
The $50M Revenue Cliff: Why Mid-Market Companies Outgrow Their ERP Exactly When They Can't Afford To
The tools that got you to $20M break at $50M. The tools that work at $200M are priced for companies that already have a team to run them. In between those two points is a gap that costs mid-market companies years of momentum — and a system migration at the worst possible time.
When to Stay: The Honest Case for Optimizing Your Current ERP Before Migrating
Not every company that's frustrated with its ERP needs a new one. Sometimes the tool is fine and the process is broken. Sometimes the implementation is under-configured rather than the software under-capable. Selling a migration to a company that doesn't need one is the same conflict of interest as the implementation partner who over-scopes everything. Here's the decision framework.
Middleware Is Not an Architecture. It's a Maintenance Contract.
Zapier, MuleSoft, Boomi, and their siblings have a legitimate role in software infrastructure. That role is not 'the connective tissue of your financial system.' When middleware becomes the thing holding your business data together, you've transferred risk without reducing it — and you've added a dependency that will require maintenance forever.
The Six-Module Constraint: Why We Didn't Build a Marketplace
Every major ERP has an app marketplace. Thousands of add-ons, integrations, and extensions — a thriving ecosystem that makes the platform more capable and the vendor more defensible. We made a different bet: six modules, one architecture, no plug-ins. The constitutional model works only if everything speaks the same language. Here's the reasoning — and the risk we accepted.
Why Your ERP Implementation Partner Has No Incentive to Simplify
Implementation consultants are paid by the hour and by the complexity of what they configure. A simpler system is a shorter engagement. More customization means more billable time during implementation, more maintenance contracts afterward, and more dependency that makes switching costly. The incentive structure of ERP delivery is pointing in the exact wrong direction for your business.
Actuals Are Sacred: Why We Made Financial Data Read-Only at the Source
Adjusting a posted entry is how small errors get quietly fixed. It's also how fraud happens. It's how audit findings get buried. It's how a company's financial history becomes something that reflects what people wanted to be true rather than what was. Immutable actuals aren't a constraint — they're the thing that makes the data trustworthy.
Customer-Level Profitability: Why Most Companies Can't Calculate It
Gross margin by customer requires connecting revenue data from the CRM or billing system, cost of goods sold from operations or inventory, and allocated overhead from finance — across systems that often don't share a customer identifier. The calculation that would most directly inform go-to-market strategy is the one that most mid-market companies can't produce without a multi-day manual exercise.
Chart of Accounts Design Is Destiny: Getting It Right Before Go-Live
A bad chart of accounts is the original sin of ERP implementations. It makes every report slightly wrong, turns every segment analysis into a workaround, and makes the next migration more painful than it needed to be. Most companies design their COA during the busiest phase of implementation, under time pressure, without fully understanding the reporting requirements that will be placed on it for the next decade.
ERP Vendor Consolidation Isn't Making Things Simpler
Salesforce buys MuleSoft. Oracle buys NetSuite. SAP buys Concur. The ERP industry has been consolidating for years, and every acquisition is pitched as a step toward the unified platform. What it actually produces, more often than not, is two separate systems with one logo on the invoice. Buying the company doesn't solve the data architecture problem.
Revenue Recognition Is Not a Spreadsheet Problem
ASC 606 compliance lives in spreadsheets at most mid-market companies. The ERP records the invoice. The spreadsheet figures out when it's actually revenue. This arrangement works until a contract gets amended, a subscription changes mid-term, or an auditor asks to see the supporting workpapers for every deferred revenue balance. At that point, the spreadsheet becomes the problem.
The Spreadsheet That Runs Your Company: Acknowledging It, Then Replacing It
Every mid-market finance team has one. The spreadsheet that is, functionally, the system of record for something important. Usually built over years by one person who understood the business deeply. Usually a masterpiece of its kind. And usually one resignation, one corrupted file, or one formula error away from a crisis the business isn't prepared to handle.
What an Alpha Tester Who Acts Like a CFO Taught Us
KC joined as our alpha tester and immediately started treating the system like a live financial operation — not a QA exercise. She wasn't looking for bugs. She was trying to run a business. The gaps that surfaced weren't failures of individual features. They were architectural assumptions we'd made about how a CFO thinks that didn't survive contact with how a CFO actually thinks.
The Parallel Run: How Long You Actually Need to Run Two Systems
Finance teams want to run old and new systems in parallel until they're confident. Implementation partners want to cut over and close the engagement. The tension between those two interests is where parallel run decisions get made — and where the consequences of getting it wrong become most visible.
Chargebee and DocuSign Are Not ERP Modules. Stop Pretending They Are.
Point solutions solve point problems brilliantly. Chargebee handles subscription billing with sophistication a general ERP can't match. DocuSign owns the e-signature market for good reason. The problem is that a signed contract in DocuSign has no knowledge of the invoice in NetSuite. Revenue recognition becomes a manual exercise in triangulation. There's a better model.
Audit Prep Shouldn't Be a Fire Drill
When auditors arrive, most finance teams shift into detective mode — reconstructing transaction trails across systems, explaining why the GL balance doesn't exactly match the billing system, producing support documents that should have been created at the time of the transaction. A system that creates audit evidence automatically, as a byproduct of how it records transactions, makes the audit a confirmation rather than a reconstruction.
Multi-Entity Without the Mess: How Intercompany Transactions Should Actually Work
Multi-entity accounting in most ERPs means running separate books and periodically trying to reconcile and consolidate them. Intercompany eliminations happen at month-end, done by hand or by a consolidation module that runs after the fact. We describe what it looks like when intercompany transactions are architecturally enforced — and eliminations happen as a property of the data, not as a step in the close.
What to Actually Negotiate in Your ERP Contract
Procurement teams focus on per-seat pricing because it's the number on the pricing page. The real negotiating leverage is in data portability clauses, implementation SLA terms, upgrade path commitments, and what happens contractually when you decide to leave. Here's the clause-by-clause checklist that rarely gets discussed before the signature.
Building on PostgreSQL: Why We Chose the Database Over the Framework
The business logic in Nue lives in the database, not the application layer. Triggers enforce financial rules before data persists. Views derive subledger balances from the ledger without maintaining separate state. Constraints prevent invalid records from existing at all. This is an architectural choice — the database is the thing that can be trusted absolutely, so the database is where the rules live.
The Real Cost of Your ERP: What's Not on the Invoice
License fees are the visible part. Below the waterline sits implementation labor, integration maintenance, staff hours spent on manual reconciliation, audit preparation, and the cost of business decisions made on data that's two systems out of sync. When you add it all up, the invoice is the least of it.
What Good Financial Reporting Actually Looks Like at Scale
P&L by segment. Department-level actuals versus plan. Cash position by entity. Customer-level margin. Most mid-market companies can produce one of these on demand. Producing all of them — accurately, in near real time, without a three-day sprint — requires an architecture most companies don't have and can't build by adding another reporting tool on top of what they already run.
The Economic Event Model: Treating Every Transaction as a Constitutional Moment
When a contract is signed, a subscription is activated, an invoice is issued, or a payment is received — these aren't separate events in separate systems. They're one economic event with one set of financial consequences. Designing software around that reality, rather than around the organizational silos that process each step, changes what the system can guarantee about the data it holds.
Data Migration Is Where ERP Projects Actually Die
The demo goes beautifully. The training sessions go well. Then someone tries to move eight years of transaction history out of four systems that never agreed on what a customer ID was. Data migration is consistently where ERP implementation plans make contact with organizational reality — and where the gap between what was promised and what's possible becomes impossible to ignore.
NetSuite Customization Is a Trap Disguised as Flexibility
SuiteScript, SuiteFlow, SuiteTalk — NetSuite's customization layer is genuinely powerful. It's also how your NetSuite installation becomes unmaintainable in three years. The path from 'small workflow tweak' to 'only our guy knows how this works' is shorter than anyone tells you at the time of sale.
What "Single Source of Truth" Actually Means (And Why Most ERPs Don't Have One)
Every ERP vendor claims to be your single source of truth. Most of them mean: 'our system is the one you should trust most.' That's authority by convention, not by architecture. There's a meaningful difference between a system that claims to be authoritative and one that is structurally incapable of being wrong — and the difference matters every time the books need to close.
Subscription Billing Is Not a Billing Problem. It's a Revenue Architecture Problem.
Chargebee, Stripe Billing, and Recurly are excellent tools for collecting recurring payments. The problem begins when someone asks 'how much revenue did we actually recognize this quarter' — and the answer lives in a spreadsheet the controller built and maintains manually. Subscription billing and revenue recognition are the same problem. Solving them in separate systems creates work that shouldn't exist.
The Decision to Build the Ledger First
Most ERP companies build the UI first and figure out the data model as they go. The UI is what sells, what gets demoed, what investors see. The data model is what determines whether the system works correctly at scale. We built the Universal Ledger as the foundation and then built every other module to serve it. Here's what that decision cost us early on — and what it made possible.
SAP for the Rest of Us: Why Enterprise ERP Logic Never Scaled Down
The architecture decisions that make SAP S/4HANA work at a 50,000-person company actively work against you at 200 people. Mid-market companies that reach for SAP don't get enterprise power at a smaller scale. They get enterprise complexity without enterprise resources to manage it.
Big Bang vs Phased Rollout: The ERP Implementation Debate That Has a Right Answer
Most ERP consultants will tell you the choice between big bang and phased rollout 'depends on your situation.' That's technically correct and practically useless. We make the case that the conditions under which each approach works are knowable in advance — and that the recommendation you're most likely to hear protects the consulting firm more than it protects your project.
Reconciliation Variance: The Bug That Became an Industry
Reconciliation software is a multi-billion-dollar market. Close management tools. Flux analysis platforms. Variance tracking dashboards. This entire category exists because the financial systems underneath produce discrepancies that need to be managed. We've built an industry to clean up after a bug that we've decided to live with.
Zoho One: The All-in-One That Still Requires a Connector
Zoho sells a suite of 45+ apps under one subscription and calls it an operating system for business. The pitch is compelling. But the financial data in Zoho Books and the CRM data in Zoho CRM live in separate databases that communicate through an API. The integration trap isn't just a multi-vendor problem. It exists inside a single vendor's product family.
Month-End Close Shouldn't Take Two Weeks. Here's Why It Does.
The dirty inventory of a slow close: waiting on AP to confirm outstanding bills, chasing intercompany eliminations across entities, reconciling the billing system to the GL, posting accruals for things the system didn't capture automatically, and investigating the three items that don't tie and never obviously explain themselves. Every one of those steps exists because the system didn't enforce something it should have at transaction time.
Database-Layer Business Rules: Why We Enforce at the Bottom, Not the Top
UI validation can be bypassed. API validation can be bypassed. A sufficiently motivated person with database access can bypass both. Database triggers and constraints cannot — they fire regardless of which path data took to get there. When the rules live at the bottom of the stack, the guarantees they produce are absolute.
The ERP Migration Fear Is Real. Here's What Actually Goes Wrong.
ERP migrations fail more often than they succeed on time and on budget. The reasons aren't mysterious — they're the same three things in almost every case: scope creep, data quality, and change management. We break down each failure mode with the specificity that vague advice about 'executive sponsorship' never provides.
Odoo Is Cheap Until It Isn't: How Open-Source ERP Still Traps You
Odoo's pitch is hard to argue with at first glance — modular, affordable, open-source, with a community edition that costs nothing. But the customization model creates a codebase only your implementation partner truly understands, and the upgrade path punishes complexity. Here's why 'free' ERP generates some of the most expensive lock-in in the market.
Subledgers as Views, Not Sources: Rethinking Financial Data Architecture
In traditional ERP, accounts receivable maintains its own truth. So does accounts payable, fixed assets, and inventory. Reconciling them to the general ledger is a scheduled ritual every finance team knows well. There's a different model: subledgers that don't maintain their own truth because they're derived from the same source as the GL itself.
Why I Spent 18 Years in ERP Implementations Before Building One
Two decades of implementing other people's ERP software gives you a specific kind of education. You learn what the systems can do and what they claim they can do. You learn where the architecture bends and where it breaks. And eventually, you have a very clear picture of the mistake that virtually every system makes in the same way — a mistake you've been working around on behalf of clients for your entire career.
The Dirty Secret of ERP "Integration": Someone Always Reconciles Manually
Every ERP vendor sells you on seamless integration. What they don't tell you is that someone on your team spends Friday afternoon proving that the number in System A matches the number in System B. That person is the integration. And they're expensive, exhausted, and one resignation away from a crisis.
The CFO's Stack in 2025: A Realistic Audit
A CFO at a $30M company is typically managing a general ledger, a CRM, a billing platform, a contract management tool, an FP&A tool, and at least two spreadsheet models that no one else fully understands. The stack has accumulated over years of legitimate decisions, each solving a real problem. What it adds up to is a finance operation that costs more to run than it should and produces data that's less reliable than it looks.
How to Know You've Outgrown Your ERP (Without Waiting for the Crisis)
The signs are subtle at first. A spreadsheet that gets emailed every Monday morning. A Slack channel that exists to coordinate between two systems. A close process that takes a little longer each quarter. None of these feel like system failures. They are. We describe the pattern — and the inflection point most companies recognize only in retrospect.
What If the Ledger Were the Law?
Most ERP systems treat the general ledger as a destination — a place where transactions land after traveling through other systems. What happens when you reverse that? When the ledger is the starting point, the rule-setter, the thing every financial event must pass through before it exists? The answer changes what financial software can actually guarantee.
Why Every Mid-Market Company Is Running Three ERPs and Calling It One
NetSuite + Salesforce + Chargebee is not an ERP stack. It's three systems that barely know the other exists, connected by middleware and manual effort. Here's a plain-English accounting of what the average $20M company is actually running under the hood — and why the gap between what they believe and what's true is costing them.