The main focus of Phillipa Martin and Allistair O’Neill’s session at DrupalSouth Melbourne was showcasing how governments can use rules as code to transform complex legislation into clear, interactive digital experiences. Drawing from the work of and Salsa Digital, the talk introduced a practical approach to codifying policies with and integrating them into Drupal CMS websites through custom web forms, enabling more consistent, transparent and accessible services for citizens.
Turning rules and legislation into interactive digital experiences – a summary
At DrupalSouth Melbourne 2025, Phillipa Martin (Rules as Code Practice Lead at Salsa Digital) and Allistair O’Neill (Assistant Director, GovCMS) shared how Rules as Code (RaC) is helping transform complex legislation into accessible, machine-readable services. Drawing from a series of real-world proof-of-concept projects, their session showcased how RaC is already delivering clearer, faster and more consistent digital experiences for citizens.
They explained how Salsa’s open source tooling, combined with Drupal CMS and the OpenFisca rules engine, enables government teams to convert legislation into logic-driven web forms. This results in scalable, transparent tools that reduce ambiguity and improve service delivery across jurisdictions.
What is Rules as Code (RaC)?
Rules as Code (RaC) is the practice of translating legislation, policies or regulations into machine-readable code that digital services can interpret. As Phillipa explained, the goal is to make complex rules easier to access, test and reuse across multiple interfaces, from websites to internal systems.
The Salsa Digital team uses a technology stack built around (an open-source rules engine developed by the French government), custom-built Drupal modules and webforms. This allows government teams to codify legislation into a central rules engine and then connect it to different user-facing services.
The strength of this model lies in its reusability and consistency. A single set of codified rules can be accessed by multiple websites, mobile apps or internal government platforms, ensuring that both citizens and public servants get the same accurate information. This cross-platform integration enables what Phillipa described as a "whole-of-government" approach to digital service delivery.
By reducing ambiguity, improving accessibility and simplifying updates to rules, RaC provides a strong foundation for modernising how governments communicate with the public. It also introduces a more transparent way to test and iterate on policy logic, making it easier to catch inconsistencies, clarify intent and model future changes.
Why Rules as Code matters for GovCMS
Allistair O’Neill, Assistant Director at , explained why Rules as Code (RaC) has become a strategic priority for the platform. With increasing interest from government departments in building smarter, more personalised digital services, GovCMS saw RaC as a natural fit for its evolving digital experience platform (DXP) roadmap.
As early as 2022, GovCMS began laying the groundwork for supporting RaC by provisioning sandpits—controlled environments where government teams could experiment with codified rules. These sandpits allow departments to validate ideas, model decision flows and test eligibility criteria before committing to full-scale development.
GovCMS partnered with Salsa Digital to guide agencies through the end-to-end process. This includes initial problem framing, rules mapping, OpenFisca implementation and Drupal integration using custom webforms. Many of these early projects focused on black-and-white eligibility logic, such as whether a user qualifies for a service, permit or benefit.
Allistair noted that more than a dozen proof-of-concept projects have already been run through this process, giving teams a practical way to explore RaC without large up-front investment. These experiments are not only helping to streamline complex services but also building internal capability and confidence within government teams.
Ultimately, the goal for GovCMS is to move from sandpits to production-ready implementations, offering reusable RaC infrastructure that departments can plug into as part of their digital service delivery.
Use cases and real-world demos
Rules as Code (RaC) is particularly effective for eligibility-based scenarios—situations where a person either qualifies or doesn’t, based on a clear set of criteria. Phillipa Martin explained that around 80% of the use cases Salsa Digital has worked on so far fall into this category, ranging from divorce eligibility to scheme compliance.
To demonstrate this, she shared two live examples built with OpenFisca and Drupal Webforms:
Federal Circuit and Family Court of Australia – divorce eligibility
Traditionally, determining eligibility for divorce required users to read through legal information and interpret complex rules on their own. The RaC demo transformed this into a guided digital journey.
Users answer a series of plain-English questions, such as whether they are currently married, how long they’ve been separated and where they were married. These inputs are passed to OpenFisca, which returns a tailored result: not just a yes/no answer, but specific documentation requirements based on the user’s situation.
Work Health and Safety (WHS) accreditation scheme
Another demo involved a building compliance scenario. The accreditation scheme’s original website contained multiple pages explaining criteria, but users often struggled to determine if the scheme applied to their project.
In the RaC version, users answer questions about the type of construction, project value and government funding. Based on this input, the system returns a definitive outcome, whether accreditation is needed, with a breakdown of which rules applied. A “Show me the rules” feature further enhances transparency by displaying the underlying logic in plain English.
Both examples highlight how RaC improves not just the back-end rule interpretation, but also the front-end user journey. By integrating business rules directly into interactive forms, users receive immediate, accurate answers without having to interpret dense legislation themselves.
This approach simplifies the process and improves transparency, helping users feel confident they understand what’s required before they begin.
Where Rules as Code works best
Rules as Code (RaC) shines in areas where legislation or policy can be translated into clear logic. According to Phillipa, eligibility is by far the most common use case, where questions like Am I eligible for a divorce?, Do I need to register under this building scheme?, or What benefits am I entitled to? are vitally important.
Calculation-heavy decisions are another strong fit. RaC tools like OpenFisca allow complex policy formulas, such as income thresholds or benefit amounts, to be encoded directly into rules engines, returning tailored outcomes for each user.
Beyond eligibility and calculations, RaC can support compliance (e.g. planning permissions), classification (e.g. product or security categories) and even some grey areas. Some models use a “you may be eligible” option when a rule can't be resolved automatically, preserving transparency while allowing human review where needed.
What makes these applications powerful is not just automation, but the user experience. Rather than navigating long legal documents or trying to interpret policy pages, users answer guided questions and receive plain-English outcomes based on their inputs. This creates faster, clearer and more consistent experiences for citizens and agencies alike.
By centralising logic in a shared rules engine, RaC also supports a whole-of-government approach. The same rule set can power both internal tools and public-facing services, ensuring citizens and public servants receive consistent answers.
Looking ahead, the most transformative potential lies in digital policy twins—interactive models of legislation that let policymakers simulate the impact of proposed changes before they're enacted. It’s a shift toward smarter governance, where laws are not only made, but modelled, tested and iterated on using real data.
What's next for Rules as Code and GovCMS
As the proof-of-concept phase matures, GovCMS is preparing to take Rules as Code (RaC) into production. The next step is a platform rollout under the name Assembl, a product designed to help agencies host and deploy OpenFisca-based RaC solutions out of the box.
This marks an important shift. Until now, RaC initiatives in GovCMS have largely focused on experimentation, upskilling and building awareness through sandpits and internal pilots. With Assembl, the goal is to offer a stable, scalable foundation that supports live RaC implementations across government.
But wider adoption still depends on agency demand. As Allistair O’Neill noted, it’s ultimately up to each department to decide whether to codify their legislation. GovCMS and Salsa Digital play an enabling role by providing the infrastructure, tools and technical expertise to make it possible.
RaC also opens the door to future use cases. By turning legislation into structured logic, agencies gain the ability to test rules, validate edge cases and identify inconsistencies early in the policy lifecycle. In some pilots, the codification process has even helped uncover flaws in existing legislation.
Most importantly, RaC is not AI, but it may one day help power it. Codified rules can provide a trusted source of truth for AI models, acting as guardrails that ensure consistency, fairness and accuracy in machine-generated responses.
As the ecosystem grows, RaC is poised to become a cornerstone of digital transformation in government, delivering more transparent, efficient and citizen-centred services built on a shared, verifiable foundation of logic.
About Phillipa Martin
Phillipa is our Rules as Code Practice Lead and also works as a content specialist. She leads the Salsa Rules as Code Practice, focusing on the business’s strategic direction and operational delivery of Rules as Code. Phillipa also works as a business analyst, mapping rules and legislation ready for developers to code.