Back to writing

Essay · Long-form

What 13 years in ERP taught me about AI adoption

The first software I shipped went out on a compact disc. From the core team of a low-code ERP platform to a headless HRMS, five lessons about how enterprises actually adopt technology. All five turned out to be about AI.

Published · September 2026~12 min read

1. The compact disc

In November 2010 I joined Ramco Systems in Chennai as a trainee programmer, and the first software I helped ship left the building on a compact disc. A deployment team collected what the platform had generated, consolidated the scripts, packaged everything as executables, wrote it to a CD and sent it to customers as a cumulative upgrade. I have since shipped products that deploy on every push to a branch. I still think about the disc, because the disc taught me what a product is.

This is a piece about thirteen years in enterprise resource planning software and what they left me with when I moved to an AI-native HR company in May 2023. I have written elsewhere about the architecture we built there. This is about why none of it felt like a leap to me, and why I think the people who spent a decade in ERP are better placed to make enterprise AI real than the people who came to it from the model side, provided they unlearn a few things.

Everything I believe about AI in the enterprise I learned before there was any AI in the enterprise.

2. A platform that rendered itself

The team I joined built Ramco VirtualWorks, the low-code platform on which the company's products were themselves built. You did not write an ERP screen. You defined it. A component had pages; pages had links to other pages; components published events and subscribed to each other's; business rules, field behaviour, localisation, client configuration, personalisation and user preferences were all definitions in the same model. From those definitions the platform generated three things: stored procedure stubs for the database layer, .NET assemblies for the middle tier, and a JSON description of every page that the front end rendered at runtime.

That last part is the one that mattered. The screen a user saw did not exist as code anywhere. It was assembled on demand from the page definition, the user's role, the client's configuration, the locale, and the user's own preferences. A field could be hidden for one client, read-only for one role, relabelled for one country, and reordered by one user, and none of those were four features. They were four rows of metadata consulted by one renderer.

For two years I did little else, and by the end of them I could answer almost any question about how the platform behaved and why. Fresher to something like platform lead in two years is not a boast; it is a description of what happens when a curious person is put inside a system where everything is visible as data. There was nothing to memorise. There was a model to understand, and once understood it explained everything built on it.

3. Lesson one: the product is the metadata

The first lesson took a decade to become useful. If a screen is a rendering of metadata, then the screen was never the product. The product is the definitions and the execution behind them: what exists, who may see it, what it does when touched, what the rules are per client and per country. The renderer is replaceable. In 2010 the renderer was a web page. It could have been anything that could read the JSON and respect the rules.

Thirteen years later, when my own engineers stopped clicking in their editors and started asking an assistant to make the change, the question that became Zero UI was not a revelation. It was the old lesson wearing new clothes. If developers will not click, why should HR users? And if the screen is a rendering, a conversation is simply another renderer, reading the same metadata, bound by the same roles, calling the same execution layer. The architecture we built, an intent classifier, a router and an engine that calls the HRMS directly with the caller's scope, is the 2010 platform with the renderer swapped and the disc replaced by a deployment pipeline.

People who came to enterprise AI from the model side tend to start with the conversation and work backwards to the system. People who came from ERP start with the system and ask what else could render it. The second group ships things that survive contact with a payroll run.

The same idea, thirteen years apart · the product is the metadata, the screen is a rendering

2010 · a low-code ERP platform

Metadata

The product, defined

Components, pages and their links, publications and subscriptions between them, business rules, field behaviour, localisation and client configuration, personalisation and user preferences. All data, none of it a screen.

Generation

Artefacts the platform writes

Stored-procedure stubs for the database, .NET assemblies for the middle tier, and a JSON description of every page for the front end. Packaged by a deployment team as a cumulative upgrade and shipped on a compact disc.

Rendering

Late-bound, on demand

The client renders the page JSON at runtime, hiding or altering fields by role, client, locale and preference. In 2013 a mobile shell rendered the same JSON inside a native container, reusing every role and every screen.

2023 onward · a headless HRMS

Metadata

The product, defined

Tenant configuration, roles and permissions, the capability catalogue, the tools an assistant may call, policies, guard rails. All data, none of it a screen.

Execution

The layer that does the work

An intent classifier, a router, and an execution engine that calls the HRMS directly with the caller's identity and scope. Deployed continuously, not on a disc.

Rendering

Late-bound, on demand

The conversation is the renderer. A screen, a chat window, a voice channel or another agent can all ask the same execution layer, scoped by the same metadata.

Everything on the left taught the author that the screen was never the product. Everything on the right is what that lesson looks like once the renderer can be replaced by a conversation.

4. Lesson two: the second interface borrows, it does not copy

In January 2013 I moved to the R&D team building mobile applications for the products the platform generated. We did what everyone did that year: native Android in Java, native iOS in Swift, one screen at a time. A few months in, the arithmetic became unavoidable. We were rewriting, by hand, on two platforms, screens that already existed as metadata on a server, with roles and access rules and field behaviour already defined. Every rewrite was a second copy that would drift from the first.

So we stopped rewriting. A Sencha Touch hybrid view inside a native container rendered the same page JSON the web client rendered, and the entire role model, every access rule and every screen came along for free. The native shell handled what only native could: the camera, the device, the store listing. Everything else was borrowed. Later, in the innovation lab, Flutter earned its place for a different class of application, the computer-vision apps that needed the device more than they needed the ERP. The rule held either way: build natively only what the metadata cannot express.

I applied the same rule again when a second product had to live next to our HRMS and the obvious design was a second database, a second login and a sync service. We put it in the same tenant database and borrowed the HRMS identity instead; that decision is written up in Two products, one tenant. It is the mobile lesson again. A second surface that copies the first one's model is a second source of truth, and a second source of truth is a bug with a release date.

5. Lesson three: integration is where the model meets reality

From June 2015 I worked alongside the human capital team on third-party integrations: a resume-parsing service, job boards, the connectors a recruiting module needs to be useful on day one. This was unglamorous work and the most instructive of the period, because an integration is the one place a beautiful internal model is forced to agree with somebody else's.

The parser was never the hard part. The hard part was the mapping: a candidate's skills as the vendor structured them into the fields this customer's recruiters actually used, with the exceptions each customer had accumulated over a decade of hiring. Ten years on, the same is true of every AI pipeline I have shipped. Reading a document is a solved problem. Deciding which of forty enterprise fields a value belongs in, with what confidence, and what happens when the answer is "none of them", is the work. The timesheet pipeline we run in production has one agent that reads and five that decide what the reading means. The ratio is the lesson.

6. Lesson four: enterprises adopt execution, not conversation

In November 2017 I moved to Singapore to set up an innovation lab co-funded by the Economic Development Board, and the first thing the lab built was chatbots: HR assistants on the Microsoft Bot Framework, in Python, for the company's HCM customers. They worked. They answered leave balances and policy questions and were demonstrated at customer events. And they were adopted the way most 2018 chatbots were adopted, which is to say enthusiastically for a quarter.

What I took from that generation is the lesson I would most want to hand to anyone building enterprise AI now. A thing that answers but cannot act is a nicer search box, and enterprises already have a search box. The assistant that stuck, years later, was the one that could execute: apply the leave, not describe the policy; raise the request, not explain the form. Execution inside the system of record, with the caller's identity and scope, is the difference between a demo and a dependency. It is also why the guard rails matter more than the model: once the assistant can act, what it is allowed to do becomes the architecture.

The lab did other things, facial recognition integrated with attendance and access control, mixed-reality training for aircraft maintenance, a pandemic-era programme that paired thermal cameras and breathalysers with turnstiles so a workforce could return to site. The pattern repeated in each. The customers who kept the system were the ones for whom it did something inside a process they already ran. The ones who enjoyed the demonstration did not.

An enterprise does not adopt a conversation. It adopts a verb.

7. Lesson five: in ERP, performance is correctness

My last large piece of work at Ramco, in 2022, was driving the modern-stack build of a next-generation payroll product whose selling point was speed: payroll runs that finished in minutes where the previous generation took hours. I had thought of performance as an engineering virtue. Payroll taught me it is a correctness property. A payroll that is late is wrong in every way that matters to the person waiting for it, and a payroll fast enough to run twice is one you can check.

That is the thinking behind Zero Touch Payroll, where the cut-off date disappears because the run is cheap enough to be continuous. It is also why I distrust any AI feature whose latency makes it something a user waits for rather than something that has already happened. In ERP, slow is a kind of wrong. The rule survives the move to AI intact.

8. What ERP people know that AI people do not

Configuration beats code. Every enterprise believes it is unique and most of that uniqueness is a hundred parameters, not a hundred features; the platform that treats them as parameters ships to the second customer. The long tail of exceptions is the product: the rule that applies to everyone except the night shift in one plant is not an edge case, it is Tuesday. Statutory change is a constant, not an event, and a system that cannot absorb a new tax table without a release is a system with a shelf life. Auditability is not a feature anyone asks for in the demo and the only one that matters in the dispute. The user is a role, not a person, and anything that forgets this leaks data within a year. And there is always an upgrade path, because there is always an installed base; the disc taught me that before the cloud made it easier to forget.

Each of those maps directly onto an AI adoption rule, and the companies that struggle with enterprise AI are usually breaking one of them: a prompt per customer instead of a configurable policy, a model that handles the common case and falls over on the plant's exception, no audit of what the agent decided, an assistant that does not know which role is asking, and no way to upgrade the model without re-validating every customer by hand.

9. What ERP people get wrong about AI

In fairness, the traffic runs both ways. The ERP instinct is to treat the model as another module: a box on the architecture diagram, specified, integrated, released. It is not a module. It is a probabilistic component whose behaviour you evaluate rather than specify, and the ERP habit of waiting for the requirements document before starting is fatal here, because the requirements only become visible once the thing is in front of real cases. We put first versions in front of users within days for exactly this reason, and the discipline that follows is described in The hardening pass.

The second ERP mistake is the demo trap in reverse. Having been burned by chatbots, ERP people dismiss the new generation as the same thing with a better vocabulary, and miss that the difference is not the conversation but the execution. And the third is the oldest: believing, after all, that the interface is the product, and asking the AI team to build a better screen.

10. The honest part

I became a founder late, at least by the standards of the people who write about founders. I joined HONO in May 2023 at thirty-four, after thirteen years at one company, and was made a co-founder two and a half years later for the product that came out of that time. I have been asked, politely and otherwise, whether that counts. I think the thirteen years are the credential rather than the delay. The platform mindset, a dynamic framework for everything, formed on a product that shipped on discs, is why a headless HRMS seemed obvious to me while it still seemed radical to the market.

Some of what I brought was baggage. The platform instinct over-configures; metadata for its own sake is a real disease and I have caught myself designing a parameter nobody will set. The ERP habit of building for the installed base can slow a company that does not yet have one. And thirteen years in one place teaches you one company's way of being right, which you then have to notice is one way among several. I unlearned those slowly, mostly by being wrong in front of engineers half my age who had never seen a CD.

What I did not unlearn, and would not, is the lesson of the disc. Somewhere inside every system worth building there is a model of the business, and everything else, the screen, the app, the chat window, the agent, is a way of rendering it. The renderers come and go. The model is the product.

The screen was always a rendering. It took thirteen years and one compact disc to see it.

The architecture this essay keeps pointing at is in Why we killed the UI; where the renderer goes next is argued in What's after the screen; and the people side of the same transition is in The bimodal developer.

Came to AI from ERP, or to ERP from AI, and recognise some of this? Let's talk.

More writing