Architecting Scalability: The case for pro-code in pricing complex risk

Who I am, and why I care about this problem

I’m Alex Karet, Solutions Architecture Lead at hyperexponential (aka “hx”). Before joining hx, I spent several years at a software consultancy, working across a wide range of industries and technologies - from projects built on low-code platforms to full-scale, pro-code application development.

When you work in insurance technology, buzzwords come and go. But few have generated as much excitement - and confusion - as low code and no code.

As the Solutions Architecture Lead at hyperexponential, I’ve spent years working with pricing, data, and transformation teams across commercial and specialty insurance. My role puts me right in the thick of discussions around system architecture, platform decisions, and that perennial question: Should we empower citizen developers, or lean into engineering muscle?

This article dives into that very question, exploring the real differences between no-code, low-code, and pro-code platforms, and why the right answer depends entirely on the complexity of the risk you're trying to price.

What do we mean by low-code, no-code, and pro-code?

When we talk about pricing in this context, we’re evaluating the platforms that allow users to build and maintain risk models - turning inputs into pricing outputs through a defined set of logic, rules, and calculations.

No-code platforms offer a purely visual interface built around pre-defined building blocks. These can be linked together to map input data to outputs, often without writing any code at all. The upside is accessibility - anyone can build something quickly. The downside is flexibility - they make it easy to build something quickly, but difficult to build exactly what you need. Customisation is deliberately limited by design.

Low-code platforms add a layer of flexibility to the no-code approach. They usually share the same visual interface and building block model as no-code platforms, but also allow limited custom coding for more complex or unsupported logic. This opens the door for power users to extend functionality beyond the default toolkit, enabling faster development without giving up all control. But these platforms still impose fundamental structural constraints, and as the complexity of pricing logic increases, those constraints can become difficult to work around.

Pro-code systems, by contrast, allow the full risk model to be expressed in real code. This gives users complete freedom to represent the pricing logic exactly as needed. Crucially, this doesn’t mean starting from scratch or losing control. Modern pro-code platforms (like hyperexponential’s hx Renew) provide the tooling, governance, and guardrails to make this safe and scalable, even for non-developers contributing to the codebase.

Why pro-code is best suited to pricing complex risk

.

Is it really that simple?

Low-code and no-code platforms are designed to make development look effortless - drag a few blocks around, wire up some inputs, and you’re done.

But as soon as you need to step outside the happy path - introduce bespoke rating logic, call external services, or handle edge cases - the limitations start to reveal themselves.

Most platforms advertise ‘custom functions’ or scripting plugins, but they’re often bolted on as afterthoughts. In practice, working around their constraints can become increasingly difficult as complexity grows.

From my experience in other industries, you often end up spending more time fighting the platform trying to make it do what you need, than you would have spent actually building your solution. This not only slows progress but increases the fragility of what you build as you end up stitching together visual components and bits of code that were never designed to work together cleanly.

The scalability challenge

Low-code and no-code platforms enable you to quickly and visually put together a pricing model. They work well for simple cases and can get you to a reasonable price fast.

But as complexity increases - more simulations, larger inputs, more intricate algorithms - no-code solutions start to struggle.

Low-code helps bridge that gap by allowing users to write code for unsupported logic, giving some flexibility when needed. But, even low-code has its limits.

As model complexity grows, so does the size of the data you need to handle, and so do the expectations of your users. This is where pro-code platforms become essential. For most use cases, you can write simple, readable code without worrying about performance or scale. But when, for example, a large property model suddenly requires pricing a massive schedule of values, you’ll be glad you can leverage the full power of a pro-code platform (instead of struggling against the constraints of no/low-code tooling).

It means you can meet the challenge without stepping outside your core system - or worse, being forced to turn the business away.

Talent, careers and ownership

One common argument for low- or no-code platforms is that they empower non-technical users to build quickly without IT support. But we need to ask: what’s the long-term impact of that approach?

Low-code and no-code platforms often require custom knowledge and training to use effectively. Despite their claims of simplicity, they usually come with a learning curve that is specific to the tool and doesn’t transfer well between platforms or to other domains. This contradicts the idea that business users can simply pick them up and start building.

In contrast, pro-code platforms - especially those that use widely adopted languages like Python - tap into a much broader hiring pool. Developers, analysts, and data scientists already know these languages, or want to learn them because they’re transferable and in demand skills.

That makes it easier to hire, train, and scale your team.

And with the rise of AI-powered tools like GitHub Copilot and ChatGPT, the barriers to working in code are lower than ever. These tools help less experienced users write code more effectively and help experienced developers move faster.

Pro-code isn’t just for engineers anymore, it’s becoming more accessible by the day.

At hyperexponential, we believe the people writing Excel formulas - the actuaries and underwriters who understand the pricing logic - should own that logic. The power of a pro-code platform is that it makes this possible without needing a team of software engineers.

By using a general-purpose language like Python, supported by strong tooling and clear guardrails, we enable domain experts to work directly in code with confidence. This allows for faster iteration, clearer intent, and shared ownership - all without sacrificing quality or control.

What I’ve seen in the real world

To keep things anonymous, I’ll use an example from outside the insurance industry.

I was once part of a project tasked with building a lightweight app to help field users track and monitor resource deployments across the country. We chose a low-code platform for speed and at first, it delivered. We got to a working prototype quickly, stitching together components in a visual editor.

It felt like we were making great progress.

But that momentum didn’t last…

As soon as real user feedback started rolling in, we hit friction. Behaviours we needed weren’t supported out of the box. Implementing changes became difficult, sometimes impossible, without major workarounds.

This reminds me of a great XKCD meme about a famously hard to learn online game. I have created my own version for no-code, low-code, and pro-code. If anyone can guess the game, and or the meme, please do reach out.

What started as a fast path to delivery became a source of delay and frustration. It was a clear lesson: the further you push low-code tools beyond their core use case, the more effort it takes to work around them and the harder it is to deliver what your users actually need.

Final thoughts: Start with the end in mind

Low-code and no-code platforms absolutely have their place. For simple, stable pricing needs - or for teams looking to build internal tools without leaning on engineering - they can offer a lot of value, fast.

But if you're pricing complex risk, with evolving models, demanding performance needs, and growing user expectations, that simplicity can become a barrier.

What feels easy at the beginning can end up slowing you down when it matters most.

Pro-code platforms provide a foundation that scales, giving teams the freedom to iterate rapidly while maintaining the guardrails needed to stay safe. At hyperexponential, we’ve designed hx Renew with these principles in mind.

Our in-platform workflow allows users to move seamlessly from development, to test, to live, with a built-in approval process that ensures changes are reviewed before deployment. The platform's containerised runtime and secure architecture mean actuaries can write and run Python safely - without needing decades of software engineering experience, or compromising the integrity of core systems.

And we don’t just stop at tooling. We offer dedicated training to help teams adopt pro-code safely and effectively. A huge part of my job is working with customers to best write pricing models in hx Renew. This includes advising on data schema design, testing, logical separation and operational governance. I have worked with dozens of insurers all with their own capabilities, skill sets and systems.

Over that time, I’ve seen how there is no right solution for how to integrate hx Renew into a customers ecosystem. Instead, there are numerous patterns that customers can utilise, depending on your particular use-case and ecosystem. The same pattern in two different scenarios can result in drastically different outcomes. It is my, and my team’s job, to work with our customers to help design how they will integrate hx Renew into their ecosystem, to ask the questions that dictate which patterns will work best, and then advise about the options available, along with their tradeoffs.

And with our Actuarial Agent, we're taking it one step further - giving actuaries AI-powered help to write, review, and understand pricing code in real time.

If you're serious about pricing - about owning your logic, scaling with confidence, and building something that lasts - start with the end in mind.

Pro-code platforms like hx Renew are designed to take you all the way there.