The Shared Platform, Part 7 of 7 · How to let enterprise clients customise without touching the core.
When we built a multi-agent sales assistant for a client, every agent could read from the client's databases and services. None of them could write. When we built an AI digital worker for refunds and chargebacks, it could prepare a refund, but a person approved it before money moved.
Both were decisions about one thing: how much power to give logic we didn't fully control.
Enterprise extensibility is the same decision at a bigger scale. Your largest clients want their own workflows, their own integrations and their own data fields. Give them direct access to the core codebase or the shared database, and one bad script can take down every product for every client. Say no to all of it, and the deal goes to a competitor who said yes.
The answer is an extensibility engine: a deliberate set of ways clients can change the platform, each with its own limits.
Configuration before code
Start with what clients can configure: feature flags, custom fields, workflow builders. A non-technical admin can tailor the product without writing a line of code, and nothing they do can reach the core.
The rule is to push customisation up, into configuration and the UI, and never down into the core.
Three levels of extension
- Configuration (no code). Toggles, custom fields and workflow builders for admins.
- Integration (low code). Outbound webhooks and event streams that push data into the client's own systems, such as Salesforce or SAP.
- Extension (pro code). Custom logic the client writes, running in isolated serverless functions such as AWS Lambda or Cloudflare Workers.
Each level up gives the client more power, and gives you more risk and more support cost. Most requests that arrive as "we need custom code" can be met at level one or two once you ask what problem the client is actually solving.
Contain the noisy neighbour
The hardest engineering problem here is isolation. One client's infinite API loop or massive data export must not slow the platform down for everyone else.
That means rate limits, resource quotas, timeouts and circuit breakers, all set per tenant. When a client's custom logic misbehaves, it should fail inside that client's own space, where their admins can see the error and the logs. It should never cascade to the shared core and take down other clients.
Isolation runs in both directions. On a platform I worked on, some partners couldn't accept concurrent orders, so we sent their orders through queues. The platform needed protecting from tenants, and some tenants' systems needed protecting from the platform.
Treat custom code as untrusted
Assume every client extension is untrusted, however large the client. Pass it the identity and permissions of the user it's acting for, through scoped tokens, and nothing more. Never give it direct access to the core database.
Start extensions with read-only access, the way our agents worked. Let writes go through the same public APIs every other product uses, so they're validated and audited. For anything that moves money or deletes data, add an approval step, the way the refund worker had one.
How much power to hand over
An extensibility engine is a set of decisions about how much power to hand to code you don't control. Give it enough to do the job, put limits on everything else, and make sure every failure stays where it started.
That's what lets sales say yes to the big enterprise deal without engineering inheriting the risk.