Skip to content

Custom Checks

The BDT platform provides a library of public eligibility checks — prebuilt rule components that cover common eligibility criteria such as age thresholds, residency requirements, and income limits. For most screeners, combining these public checks is sufficient to express the required eligibility logic.

However, if the public checks do not cover a requirement specific to your use case, BDT allows you to build your own reusable custom checks.

A custom check works exactly like a public check within your screener:

  • It accepts one or more inputs from the screener form
  • It evaluates a defined condition
  • It returns an eligibility result (True or False)

The key difference is that you define the logic yourself using DMN (Decision Model and Notation), a low-code standard for expressing decision rules.

Once created and published, your custom checks appear alongside public checks in the Configure Benefit page and can be reused across multiple screeners.


Custom check logic is defined using DMN with expressions written in FEEL. Neither requires traditional programming experience, but understanding their core concepts will help you build effective checks.

Decision Model and Notation (DMN) is an open standard for modeling and executing decision logic. It provides a visual, structured way to express rules that a system can evaluate automatically.

In BDT, each custom check is backed by a DMN model. Decisions can use decision tables or a literal expression, such as the income comparison in the example below.

DMN models have two main building blocks:

  • Input Data nodes — represent values coming in from the form or from configured parameters
  • Decision nodes — represent rules that evaluate those inputs and produce an output

FEEL (Friendly Enough Expression Language) is the expression language used inside DMN to write rule conditions and computed values.

FEEL is designed to be readable and approachable. A few examples:

FEEL Expression Meaning
age >= 65 Age is 65 or older
state = "California" State equals California
income < 2000 Income is less than 2000
date("2024-01-01") A specific date literal
age >= minAge and age <= maxAge Age falls within a range

FEEL supports arithmetic, comparisons, logical operators (and, or, not), date functions, string functions, and more.

The most common way to express eligibility logic in DMN is a decision table — a structured grid where each row is a rule.

Each rule specifies:

  • Input conditions — the values or ranges that must be true for this rule to apply
  • Output — the result returned when the rule matches

BDT eligibility checks always return true (eligible), false (not eligible), or a value indicating insufficient information.

Example — Minimum Age Check:

Age (Input) Eligible (Output)
>= 65 true
< 65 false

Example — Income and Household Size Check:

Household Size (Input) Annual Income (Input) Eligible (Output)
1 <= 20000 true
2 <= 27000 true
any > 50000 false

Identifying the result node:

When you create a custom check in BDT, you give it a name (for example, “Household Income Limit”). Your DMN model must contain a decision node with that exact same name. BDT uses this naming convention to identify which decision node represents the final eligibility result for the check. All other decision nodes in the model are treated as intermediate steps that feed into it.

For a deeper understanding of DMN and FEEL, refer to the official documentation:


The Custom Checks view lists all of the custom checks you have created. Select Custom Checks in the top navigation bar.

From this view, you can:

  • View all of your custom checks
  • Create a new custom check
  • Open an existing check to edit or publish it
  • Rename a check’s draft, then review and publish the new name
  • Archive a check that is no longer in use, or restore an archived check

Custom Checks view showing the Create New Check control and the example’s two custom checks.

New accounts include the two custom checks that the example screener’s fictional Philly Cash benefit uses: Would like extra cash and Household income limit. The rest of this guide walks through Household income limit, which compares a household’s yearly income with a limit that each benefit sets. Open it in your own account to follow along.

To create a new custom check, select Create New Check. You will be prompted to provide:

  • Name — a descriptive name for the check (e.g., “Household Income Limit”)
  • Module — the category or group that this check belongs to (e.g., housing)
  • Description — a brief explanation of what the check evaluates

For example, a check that a household has enough people for a program could be named Minimum household size in the Philadelphia examples module, where the example’s checks are.

Create New Check dialog filled with Minimum household size, the Philadelphia examples module, and a one-sentence description.

Select Add Check, then Edit on the new card to open the Custom Check Editor. The check includes a starter DMN model. From there, configure parameters, define the logic, test it, and publish it.

Select Rename on a check’s card, enter the new name, then select Save draft name. The name takes effect immediately in your draft. Publishing remains a separate action so you can review and test all saved changes first.

After saving, select Review & publish to open the check’s Publish tab, or Done to keep working on the draft. Publish a new version to make the new name available when adding checks to a benefit. Previously published versions and benefits using them keep their current names.


When you open a custom check, you are taken to the Custom Check Editor. This editor has four tabs that guide you through the process of building and publishing a check:

  • Parameter Configuration — define configurable inputs for your check
  • DMN Definition — build the decision logic using the visual DMN editor
  • Testing — run the check against sample inputs to verify it behaves correctly
  • Publish — publish a version of the check to make it available in your screeners

Custom Check Editor for Household income limit, showing its incomeLimit parameter and the Parameter Configuration, DMN Definition, Testing, and Publish sections.


The Parameter Configuration tab is where you define inputs that can be configured when adding your check to a benefit, rather than being supplied directly by the form.

What is a parameter?

Most eligibility checks involve a threshold or reference value — for example, a minimum age or an income limit. Rather than hardcoding that value in your DMN logic, you can expose it as a parameter. When you add the check to a benefit, you supply the specific value for that parameter. This makes the check reusable across multiple benefits with different thresholds.

Example: The Household income limit check exposes an incomeLimit parameter. Philly Cash sets incomeLimit to 40000; a benefit for another program could set it to 20000. The same check logic serves both without modification.

Adding a parameter:

Select Create New Parameter and fill in the following fields:

  • Key — the internal identifier used in your DMN model to reference this parameter (in the example, incomeLimit)
  • Label — the human-readable name displayed when configuring the check on a benefit
  • Type — the data type: String, Number, Boolean, Date, or String List
  • Required — whether the parameter must be provided when the check is added to a benefit

Select Add Parameter to save it. To change a parameter later, select its card. In the example, incomeLimit is a required Number labeled Yearly household income limit ($):

Edit Parameter dialog showing incomeLimit as a required number with the label Yearly household income limit ($).

The applicant’s householdIncome is form data. The program’s incomeLimit is a parameter, supplied to DMN inside the parameters context.


The DMN Definition tab contains the visual DMN editor where you define the decision logic for your check.

The editor provides a graphical canvas for building your DMN model. You can create and connect decision nodes, define input data sources, build decision tables, and organize decisions into a Decision Service.

The example’s model has two Input Data nodes: householdIncome of type number, and parameters of a structured type containing an incomeLimit number. In Data types, this structured type is defined as tParameters. Both inputs connect to the Household income limit decision, whose result type is boolean. The decision name must be identical to the check name. A text annotation explains the model to anyone who opens it.

DMN Definition showing householdIncome and parameters connected to the Household income limit decision, with an explanatory annotation.

Open the decision’s expression editor to see its FEEL literal expression:

if householdIncome = null or parameters.incomeLimit = null then null
else householdIncome <= parameters.incomeLimit

This returns true when income is at or below the limit, false when it is above the limit, and null when either value is missing. Defining a parameter in BDT does not automatically create its DMN input node; the model must include the parameters context too.

Saving your work:

Select Save Changes to persist your DMN model. The save button turns yellow when there are unsaved changes, so you can tell at a glance whether your current edits have been saved.

Validating your DMN:

Select Validate Current DMN to check your model for structural or syntax errors. If validation issues are found, a summary of the errors is displayed. Resolve all validation errors before testing or publishing your check.


The Testing tab lets you run your check against sample input data to verify that it evaluates correctly before publishing.

The screen is split into two panels:

Left panel — Test Inputs:

Enter a JSON object representing the form inputs you want to test with. Each key in the JSON should correspond to an input defined in your DMN model.

Example:

{
"householdIncome": 30000
}

Right panel — Check Summary:

Displays information about the check being tested, including its configured parameters and their current values.

Click the check card to configure the test parameter. Set incomeLimit to 40000, the limit Philly Cash uses, then select Confirm. The parameter is supplied separately from the applicant JSON.

Configure Check dialog setting incomeLimit to 40000 for a test run.

Running a test:

Select Run Test to evaluate the check against your input data. The result is displayed as:

  • Eligible (green) — the check returned true
  • Ineligible (red) — the check returned false
  • Need more information (yellow) — the check could not determine eligibility from the provided inputs

Use the testing tab iteratively as you build your DMN logic to confirm each rule behaves as expected.

With householdIncome set to 30000 and incomeLimit set to 40000, select Run Test. Latest Test Data records the input used, and Latest Test Result shows Eligible.

Testing tab with householdIncome 30000, incomeLimit 40000, and an Eligible result.

Change the JSON income to 50000 and run the test again. The same rule now returns Ineligible. Also test the boundary (40000, eligible) and an unanswered value ({"householdIncome": null}, need more information) before publishing.

Testing tab with householdIncome 50000 and an Ineligible result against the same 40000 income limit.


The Publish tab is where you publish your custom check to make it available in the Configure Benefit page of your screeners.

Eligibility checks use semantic versioning. Each time you publish, a new version is created. Previously published versions are preserved and remain available.

Publishing creates a snapshot of all saved changes, including the name, parameters, and DMN model. Save and test your changes before publishing. Subsequent edits do not affect already-published versions. You must publish again to make new changes available.

The publication status shows Not yet published, Unpublished changes, or All saved changes published, along with the latest published name and version. When all saved changes match the latest version, the publish button is disabled.

To publish a check:

Select Publish Check. A success message confirms publication, and the Published Versions list updates immediately, sorted from newest to oldest. If publication fails, an error is displayed and you can retry. The example’s check is already published as version 1.0.0, which Philly Cash uses.

Existing benefits continue using the check version they already have. To use the new version, remove the old check and add the new one in Configure Benefit, then configure its parameters. Republish the screener when you are ready to make that change available to its users.

Publish tab showing Household income limit version 1.0.0 in Published Versions, with the Philadelphia examples module and one parameter.

Published version details:

Each published version displays:

  • Name — the check name
  • Version — the semantic version number (e.g., 1.0.0)
  • Module — the module identifier

Once published, the check and its version will appear in the Custom Checks tab when adding eligibility checks to a benefit in any of your screeners. Configure incomeLimit for that benefit and connect a numeric form field to custom.householdIncome, as Philly Cash and the example form do. The screener passes fields under custom to the custom DMN model; the Testing tab accepts the unwrapped input shown above.