Your ERP Shouldn’t Hit a Ceiling: Custom ERP Development on Frappe

Most custom ERP projects don’t fail because the platform was too weak. They fail because the team used the wrong layer of it — and discovered the ceiling six months in, after the budget was spent and the business had already reshaped itself around the half-built system.

We’ve spent more than a decade building enterprise software, and we keep meeting the same situation: a company picked an ERP, customized it through the visual "low-code" tools, and then hit a wall the moment their process stopped looking generic. The fields wouldn’t compute the way they needed. The workflow engine couldn’t express their approval logic. The integration to the machine on the shop floor simply had no home. So they concluded the platform couldn’t do it — when in fact they’d been building on the wrong floor of the building the whole time.

This is the single most important thing to understand before you commission a custom ERP, so we want to say it plainly.

The low-code ceiling is real — and it’s avoidable

Platforms like ERPNext, built on the Frappe framework, present two very different surfaces, and they fail in completely different ways.

The surface most people see first is the low-code layer: custom fields, form customization, client scripts, server scripts, the visual workflow builder. It’s fast, it’s friendly, and for light tweaks it’s genuinely excellent. But it has a ceiling. Scripts run in a constrained, sandboxed environment. The workflow engine assumes fairly linear logic. When your requirements are simple, you never feel the wall. When they’re not, you hit it hard — and that’s the experience that gives "low-code ERP" its bad reputation for serious work.

Underneath that surface is the part most teams never reach: Frappe itself, a full-stack Python web framework. At this layer you write a real application — proper Python controllers, lifecycle hooks, scheduled jobs, background workers, a clean REST API, and unrestricted code that can import anything and integrate with any external system. It’s version-controlled, testable, and deployed through a normal CI pipeline. No visual builder, no sandbox, no ceiling.

The difference between an ERP project that thrives and one that stalls is almost always this: was the heavy customization built as a proper Frappe application, or was it crammed into the low-code layer until that layer gave out? We build at the framework layer. That’s the whole game.

Why we build on Frappe instead of from scratch — or on a heavyweight suite

There’s a tempting instinct to either buy the biggest enterprise suite or build everything from a blank page. Both are usually mistakes for small-to-mid businesses, and Frappe sits in the productive middle for a specific reason.

A heavyweight commercial suite makes you pay — in licensing and in mandatory consultants — for an enormous feature set you’ll mostly never use, and it makes the smallest change expensive and slow. Building from a blank page, on the other hand, means re-implementing the boring, solved 70% of every ERP: the accounting ledger, the stock movements, the order-to-cash flow, the permission system. That’s not craftsmanship; it’s reinventing wheels that have been round for twenty years.

Frappe gives you the solved 70% as a mature, battle-tested domain model — and then gets out of your way for the 30% that’s actually specific to your business. You own the result completely. No per-user licensing meter quietly shaping your architecture. No vendor lock-in. The full source, hosted where you choose. For a business that wants its software to be an asset rather than a recurring liability, that ownership is the entire point.

It’s also Python, top to bottom — which matters more than it sounds. It means the people maintaining your system are working in one of the world’s most common languages, not a proprietary scripting dialect that evaporates the day your one specialist leaves. Your system stays maintainable by ordinary good engineers, which keeps it alive and affordable for years.

What we actually build

A Frappe-based engagement with us typically looks like this. We keep the standard modules that already fit your business — accounting, inventory, buying, selling, the manufacturing core — because rebuilding them would be pure waste. Then we build your differentiators as a dedicated custom application on top:

The parts of your process no off-the-shelf system understands — a pricing engine that computes quotes from dimensions or material weight, a configurator that generates a bill of materials from customer inputs, costing logic that matches how you actually account for jobs. The integrations that connect the ERP to the rest of your operation — shop-floor machines, payment gateways, logistics providers, e-commerce channels, existing legacy systems. And the reports, dashboards, and documents your team and your customers actually need, rather than the generic ones that ship in the box.

The result is a system that feels like it was made for your business, because the 30% that’s yours genuinely was — while the 70% that’s universal didn’t cost you a cent of reinvention.

Made-to-order, manufacturing, and the businesses this fits best

Frappe and ERPNext were essentially designed around the assumption that most small and mid-sized manufacturers build because someone ordered — make-to-order and configure-to-order are first-class, not afterthoughts. If you run production against customer orders, manage variants and bills of materials, and need the shop floor, inventory, and accounting to stay in sync automatically, this platform fits your shape natively. The customization rides on top of a domain model that already thinks the way you do.

We’re equally honest about where it isn’t the right tool. If every order is a unique engineering project with bespoke design work, or if what you need barely resembles an ERP at all, we’ll tell you — and we’ll propose a leaner, purpose-built system instead. We’d rather lose a Frappe engagement than sell you a platform that fights your business. That honesty is, frankly, why our clients keep coming back.

How we work

Every engagement starts with a short, fixed-scope discovery before anyone quotes a build. We map your actual processes, separate the genuinely standard parts from the genuinely bespoke ones, and tell you candidly which is which. You get a clear picture of what’s configuration, what’s custom development, and where the real effort — and cost — concentrates. No surprises in month six.

From there we build at the framework layer, version-controlled and tested, with staging environments and disciplined migrations so customizations survive platform upgrades instead of turning every update into a crisis. And because the whole thing is open and Python-based, you’re never locked to us — you own a system any competent team could maintain. We think that’s exactly why you should want to work with people confident enough to build it that way.

Let’s find out if it fits

If you’re weighing a custom ERP — or you’ve already hit the ceiling on one and you’re wondering whether to push through or start over — a conversation costs you nothing and will save you from the expensive version of finding out.

Tell us what your business actually does, and we’ll tell you honestly whether Frappe is the right foundation, where the customization effort would land, and what it would realistically take. If it’s a fit, we’ll build you something you own. If it’s not, we’ll say so.

Simplico — software engineering and product studio, Bangkok. Building custom ERP, AI, and integration systems for Thai, Japanese, Chinese-speaking, and global markets for over a decade.

Get in touch: tum@simplico.net · simplico.net