When Congress raises the SNAP income threshold or your state legislature modifies TANF work requirements, legacy systems require months of developer time to update the COBOL code that nobody fully understands. Commonwealth separates policy from code. Administrators configure eligibility rules through a visual interface — and deploy changes the same day the regulation takes effect.
Your eligibility system runs on COBOL. The programmer who wrote the SNAP income threshold logic retired in 2014. The code contains comments in a language nobody in your agency speaks anymore. When the federal government updated the gross income limit last October, it took your IT contractor eleven months and $2.4 million to change a number in a database table — because that number was hardcoded into procedural logic that interacts with eighteen other modules, each of which required regression testing against test cases that hadn't been updated since 2009. And during those eleven months, caseworkers used a manual workaround — a printed memo taped to their monitors reminding them to override the system's determination for households between the old and new thresholds.
Commonwealth's rules engine exists to make that story impossible. Every eligibility rule — every income threshold, every deduction table, every categorical pathway, every benefit calculation formula — is configured through a visual interface by policy administrators who understand the regulation. Not coded by developers who understand the programming language. When the regulation changes, the rule changes. The same day. With a complete audit trail showing exactly what changed, who changed it, when, and why.
Updating the SNAP gross income threshold from 185% to 200% of the Federal Poverty Level.
From visual rule building to automated case re-evaluation — every capability needed to make policy changes as fast as the regulations that drive them.
The visual rule builder is the core of Commonwealth's policy engine. Rules are constructed from three building blocks: conditions (IF gross income ≤ 200% FPL), thresholds (shelter deduction cap = $672), and actions (THEN benefit = max allotment - 30% of net income). Policy administrators drag, connect, and configure these blocks in a visual canvas — seeing the rule logic in human-readable language at every step. The builder validates rules in real time, highlighting logical conflicts, unreachable conditions, and missing edge cases. When a rule is ready, the administrator previews its effect against historical case data before deploying. The entire process — from reading the federal memo to deploying the updated rule — takes hours, not months. And the person making the change is the person who understands the policy, not a developer interpreting a requirements document.
Agencies should not have to build eligibility rules from scratch. The federal regulations that govern SNAP, Medicaid, TANF, WIC, and other programs are substantially similar across all states — the differences are in state-specific policy overlays. Commonwealth maintains a federal regulation library: pre-built, validated rule templates for every major program, maintained by a dedicated policy team that monitors the Federal Register, USDA FNS memos, CMS State Medicaid Director letters, and ACF policy guidance. When a federal regulation changes, Commonwealth's policy team updates the federal rule template and delivers the update to all deployed states within 48 hours — as a configuration change that state administrators review, customize for any state-specific variation, and deploy. The state's responsibility is adapting the template to their specific policy choices, not building the federal logic from scratch.
Every state makes policy choices within the framework of federal regulation — and these choices are where most implementation complexity lives. Does the state use broad-based categorical eligibility for SNAP? What earned income disregard does the state apply for TANF? Does the state extend Medicaid to 138% FPL under expansion, or use a different threshold? Has the state waived the SNAP asset test? Commonwealth manages these as configurable state policy overlays that sit atop the federal rule base. The overlay system ensures that federal updates never overwrite state-specific choices, that state changes are independently testable, and that the audit trail clearly distinguishes between federal-mandated rules and state policy options. When a state legislature changes a policy — raising the childcare copay threshold, for example — the administrator modifies the state overlay without touching the federal base.
Every October, the Federal Poverty Level guidelines update. Every year, SNAP maximum allotments change. Deduction caps adjust. State Median Income percentages shift. In legacy systems, each of these annual changes requires a development cycle — because the threshold values are embedded in program logic, not stored in configurable tables. Commonwealth maintains all thresholds in dedicated, version-controlled configuration tables that administrators update through a spreadsheet-like interface: FPL thresholds by household size, SNAP maximum allotments by household size, standard deduction amounts, shelter deduction caps, earned income disregard percentages, childcare copay schedules, and WIC income guidelines. Each table carries an effective date — so future-year values can be pre-loaded and activated automatically on October 1 without any manual deployment step.
Income deductions and disregards are where eligibility determination gets complicated — and where most COBOL-era errors originate. SNAP allows a standard deduction, an earned income disregard of 20%, a dependent care deduction, an excess shelter deduction (capped for non-elderly/disabled, uncapped for elderly/disabled), and a medical expense deduction for elderly/disabled members. TANF applies different earned income disregards — often with time-limited transitional disregards. Childcare programs may disregard a percentage of child support received. Commonwealth manages all deductions and disregards in program-specific configuration tables — each with its own eligibility conditions, calculation methodology, applicable populations, and caps. When a state changes an earned income disregard percentage for TANF, the change affects only TANF calculations — never SNAP or Medicaid. Each deduction carries its own effective date, enabling prospective and retrospective application.
When a fair hearing officer asks "what rules were in effect when this determination was made?" the answer must be immediate, complete, and defensible. In COBOL systems, the answer requires archaeology — searching through code repositories, change request logs, and deployment records to reconstruct the logic that was running on a specific date. Commonwealth maintains a complete, immutable version history of every rule, every threshold, every deduction table, and every policy overlay — timestamped, attributed to the administrator who made the change, linked to the regulatory authority that required it, and instantly retrievable. The system can reconstruct the exact eligibility determination that would have been produced under any prior version of the rules — enabling fair hearing officers, quality control reviewers, and federal auditors to verify that the determination was correct under the rules as they existed at the time.
The biggest risk in policy changes is unintended consequences — a threshold adjustment that accidentally disqualifies a population that was meant to remain eligible, or a deduction change that interacts with another program's rules in an unexpected way. Legacy systems mitigate this risk through extensive regression testing that takes weeks and still misses edge cases. Commonwealth's impact simulation engine evaluates rule changes against the actual caseload before deployment: the administrator clicks "simulate" and sees exactly how many cases would be affected, how many would gain or lose eligibility, how benefit amounts would change (in aggregate and for representative cases), and whether any logical conflicts or edge cases exist. The simulation runs against 10,000+ historical case scenarios that cover the full diversity of household compositions, income levels, and program combinations. Only after reviewing the simulation results does the administrator deploy the change.
A rule change without case re-evaluation is incomplete — families affected by threshold increases, deduction changes, or new categorical eligibility pathways must be identified, their eligibility re-determined, and their benefits adjusted. In legacy systems, this is a months-long batch processing exercise. Commonwealth automates the entire chain: when a rule is deployed, the system immediately identifies every active case that is affected by the change, re-evaluates each case under the new rules, calculates the new benefit amount, generates the required notice to the family (including the old amount, new amount, reason for change, and fair hearing rights), and updates the case record. For threshold increases that expand eligibility, the system can also identify pending denied applications and recently closed cases that would now qualify — enabling proactive outreach to families who were denied under the old rules but are eligible under the new ones.
When USDA FNS increased the SNAP gross income threshold from 185% to 200% of the Federal Poverty Level, states running legacy COBOL systems estimated 6-18 months for implementation. The state running Commonwealth deployed the change in 4 hours: a policy administrator updated the threshold in the visual rule builder, ran the impact simulation (showing 34,000 households newly eligible), reviewed the results, and deployed the rule. Within 24 hours, all 34,000 newly eligible households were identified, and outreach notifications were sent inviting them to apply. The state enrolled 28,000 of them within 60 days — while other states were still waiting for their COBOL modifications to complete QA testing.
During the COVID-19 emergency, Congress and USDA issued 14 significant SNAP policy changes in 90 days — emergency allotments, expanded categorical eligibility, suspended work requirements, pandemic EBT, extended certification periods, and waived interview requirements. States running legacy systems were overwhelmed: the average state implemented only 3 of the 14 changes within 90 days, relying on manual caseworker workarounds for the rest. The Commonwealth state deployed all 14 within the 90-day window. Each change followed the same pattern: policy administrator configures the rule, simulation confirms the impact, rule deploys, affected cases re-evaluate automatically. No developer involvement. No regression testing backlog. No printed memos taped to monitors.
A state legislature passed a bill in May changing the TANF earned income disregard from 50% of the first $200 to 100% of the first $350 — effective July 1. In legacy states, a May-to-July implementation timeline would be impossible. The Commonwealth policy administrator configured the new disregard rule in 2 hours, ran the impact simulation (showing 4,200 TANF families would receive higher benefits), pre-loaded the rule with a July 1 effective date, and the system activated it automatically on July 1. All 4,200 affected cases were re-evaluated overnight. Benefit increase notices were mailed on July 2. Over the following 12 months, zero fair hearing decisions were reversed due to incorrect rule implementation — because the rule was configured by the policy expert who understood the legislative intent, not interpreted by a developer reading a requirements document.
I have been a SNAP policy director for sixteen years. For sixteen years, every time a federal regulation changed, I wrote a requirements document, gave it to the IT contractor, and waited. Six months. Twelve months. Eighteen months. And when the change finally deployed, it was wrong in a way that only someone who understood the regulation would catch — because the developer implemented the logic correctly but misunderstood the policy intent. With Commonwealth, I make the change myself. I see the rule in language I understand. I test it against real cases. I deploy it. And when the fair hearing officer asks why this case was determined this way, I can show them the exact rule — in plain language — and the regulatory authority that required it. I do not call the IT contractor. I do not read COBOL. I am a policy professional doing policy work for the first time in my career.
COVID broke every legacy system in the country. Fourteen SNAP policy changes in 90 days. Our COBOL system had a 6-month backlog before COVID hit. We implemented three of the fourteen changes in the first 90 days. Three. The other eleven were handled with manual workarounds — printed memos, caseworker overrides, and prayer. The state running Commonwealth deployed all fourteen. All fourteen. While we were taping memos to monitors telling caseworkers to ignore the system's determination for emergency allotments, they had already automated the entire process and moved on. That is when I knew our system had to go. Not eventually. Now.
The legislature passed the earned income disregard change in May with a July 1 effective date. My counterpart in the neighboring state told me their system wouldn't have the change ready until February — eight months after the effective date. For eight months, their caseworkers would manually override the system for every affected TANF case. Our policy administrator configured the rule on June 15, tested it against 4,200 affected cases, pre-loaded it with a July 1 effective date, and went home. On July 1, the system activated the new rule automatically. By July 2, every affected family had a new benefit amount. Zero fair hearing reversals in twelve months. Zero. Because the rule was written by someone who read the statute, not someone who read a requirements document about the statute.
Request a demonstration of the Rules Engine — including the visual rule builder, impact simulation, and automated case re-evaluation.