The Film Awards team had been working around Nucleus by creating artificial categories triggered by form logic, then applying per-category pricing to those categories. It worked, but it was brittle. They still needed manual admin intervention for discounts, and the whole setup was difficult to reason about for them and for us. More importantly, it revealed something I’d been circling around during the admin redesign planning: pricing information was scattered across Nucleus with no single source of truth.

The problem

The timing mattered. We were gearing up for the admin redesign, and one of the most consistent requests from administrators was to consolidate related functionality onto single screens. Our original design philosophy had been to place features where they logically belonged: category pricing in the categories section, form logic in the form builder, award settings in their own area. Technically sensible. Operationally incoherent. To understand how an award’s pricing actually worked, an admin had to navigate between multiple sections, piecing together the full picture themselves.

The Film Awards workaround wasn’t an edge case. It was a symptom. If pricing configuration was this fragmented, we needed to rethink the architecture entirely.

The solution

I started by cataloguing every pricing model in Nucleus: base prices, per-category pricing, early bird discounts, late fees, and the various conditional logic some clients had built. Then I worked through what parameters each would need if we moved everything into a single unified table with a rules engine underneath. Each rule would be processed in sequence, and the final calculated value would be the entry fee.

The obvious risk was that more flexibility means more room for mis-configuration. Administrators could theoretically create contradictory rules that broke their pricing entirely. Developers typically guard against this by constraining the UI, limiting what users can do to prevent mistakes.

But the data showed something different. Most clients used relatively simple pricing management setups. They weren’t combining every possible feature simultaneously. The clients who did use complex configurations were sophisticated enough to test their work properly. The cost of the existing fragmentation was higher than the risk of administrators creating conflicting rules.

I took the concept to the CTO with a clear position: let’s stop designing around preventing mistakes and instead give users visibility and testability. If they mis-configure something, they’ll see it immediately in the unified table and they’ll have proper tools to test and fix it. He agreed, and we refined the technical approach over several sessions until we had a detailed enough spec for development.

The developer who picked this up rose to the challenge, but it was complex work. We had several refinement sessions as he encountered edge cases and implementation challenges. The biggest breakthrough came from his suggestion to build a dry-run test suite directly into the pricing interface. Administrators could simulate scenarios without creating actual entries or invoices, eliminating the operational mess of generating and cleaning up test data. That idea transformed the feature from functional to genuinely usable.

When development stabilised, I tested it against every client configuration I could access, identifying edge cases that we resolved before launch.

The impact

The unified pricing table has fundamentally changed how administrators work with pricing in Nucleus. Everything pricing-related is now visible in one location, making it immediately clear what’s configured. Administrators can validate complex pricing setups without operational overhead. The Film Awards team no longer needs their category-based workaround and can model their actual workflow directly. And we’ve created architecture that supports future pricing models without scattering configuration across the product again.

This appeared deceptively simple from the outside, just moving pricing to one table, but it represented a major architectural shift. It reduced cognitive load for administrators, improved operational accuracy, and positioned Nucleus to handle the next decade of awards workflows without accumulating the same technical debt.