An expression engine may look like a small formula box, but once a platform uses it for computed fields, validation, visibility, workflows, filters, and automation, it becomes part of the platform’s shared language. If those features interpret formulas differently—or enforce rules only on one screen—users can learn the wrong lesson about what a rule actually guarantees.
That is the central argument of informat’s September 27, 2026 DEV Community essay, “The Expression Engine Is Small. That Is Exactly the Problem.” Its incident and design choices are the author’s account, not independently verified case-study findings. The architectural questions it raises are useful wherever one expression system serves many parts of an application.
Why a small expression engine can have platform-wide consequences
A formula language can start as a convenience for one feature and quietly become the mechanism behind many. Informat lists computed fields, defaults, validation rules, visibility conditions, workflow branches, report and list filters, and automation thresholds as places expressions may appear. Users experience those as distinct features, but they may depend on the same syntax and semantics.
If a comparison, blank value, or function behaves differently from one feature to another, users cannot reliably transfer what they learned. A condition that hides a field is not necessarily the same kind of promise as a rule that rejects a write, even if both are entered as expressions. Informat’s memorable framing is that an expression engine is “not a feature. It is a language.” That is the author’s characterization, not a formal technical definition.
#1 Best Overall
What the reported discount incident illustrates
Informat recounts a distributor’s quoting application with a rule intended to keep discounts below 30 percent unless an approval flag was present. According to the essay, an 80 percent discount entered during a product-line migration through a bulk import, and the rule did not run because it was attached to form behavior rather than the import/write path. The author says the customer’s finance lead had written the rule.
The essay provides no customer name, system records, or independent corroboration, so the episode should be read as the author’s account—not as a verified incident or evidence of how often this failure occurs. Its design lesson is narrower and concrete: if a condition must hold for stored data, enforcement belongs wherever writes can enter, not just on a particular screen.
Decide what each expression is supposed to guarantee
Separate immediate feedback from data constraints
Some expressions improve the experience while a person is interacting with a screen. A visibility condition, for example, may be evaluated in the browser so the interface can respond as the user types. A rule meant to prevent invalid data from being stored has a different responsibility: it must be evaluated on the write path that accepts the change.
Informat proposes browser-side evaluation for visibility and server-side enforcement for validation, computed fields, and workflow branches that protect data constraints. The key question is not simply “where does this formula run?” but “which paths can write data, and do they encounter the enforcement?” Forms, imports, APIs, and automations should be considered explicitly. This is a design recommendation from the essay, not a claim that every low-code platform uses these execution paths.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #3
Make the enforcement boundary visible
Users need to be able to tell whether an expression is advisory or authoritative. Informat puts the distinction sharply: “The moment a rule is a property of a screen, you have shipped a suggestion, not a constraint.” The practical implication is to label and document the rule’s scope, and to avoid presenting a screen-only check as protection for stored records.
Treat field references as schema dependencies
A formula that refers to a field depends on that field continuing to exist with a compatible meaning. Informat recommends representing those references in a dependency graph and checking formulas against the schema when they are saved. This can help surface invalid references early rather than leaving a formula that appears intact in an editor but fails at runtime.
Rank #4
Renames and deletions need deliberate handling. Where a rename can be applied safely, references can be updated atomically. Where a deletion or schema change cannot be repaired automatically, the platform should present an actionable warning at the time of the change. These are practices proposed by the essay’s author; the source does not establish them as universal requirements or report comparative testing.
Specify missing values, types, and dates
Define blank, null, and zero
“Missing” is not a complete semantic rule. A system needs to say whether empty text differs from null, and whether a numeric field that has never been set differs from a value of zero. It also needs to define what happens when a validation expression cannot reach a determinate result because required data is absent.
Best Value
Informat reports choosing fail-closed validation when a rule cannot evaluate its required data: the write is not accepted as valid merely because the rule could not decide. That is the author’s chosen behavior, not a universal standard. The important architectural choice is to define and document the behavior instead of letting it emerge from implementation details.
Prefer explicit conversions and date semantics
The essay favors strict type coercion, with explicit conversion functions rather than silently treating a numeric-looking string as a number. This makes the expression’s intent easier to inspect and reduces reliance on implicit interpretation. Informat also says the author’s platform distinguishes a zoned instant from a plain calendar date, which can matter when an expression is evaluated in different time zones. The source supplies no test data or independent verification of those implementation outcomes.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Keep expression capabilities inside a deliberate security boundary
Expression languages can gain risk as requests add capabilities one function at a time. Informat recommends keeping formulas focused on computation over the attached record, offering a whitelist of pure functions, and making access to other-table data explicit and permission-checked. More expansive behavior belongs in a separately governed scripting layer, according to the essay’s proposed model.
This is a security design recommendation, not a formal threat model or security audit. For a platform team, the useful questions are what data an expression can read, whether each read respects the user’s permissions, and whether a request for broader behavior is being handled as a scripting capability rather than casually added to the formula environment.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →A practical review checklist for expression architectures
- Consistency: Do expressions share syntax, function behavior, type rules, error reporting, and evaluation timing across features?
- Schema changes: Are field references tracked, checked on save, and handled visibly when a field is renamed or deleted?
- Value semantics: Are blank, null, zero, invalid conversion, and indeterminate validation outcomes documented?
- Write coverage: Which expressions run in the browser and which run on the server? Do constraints cover forms, imports, APIs, and automations that can write records?
- Security: Are functions pure and allowlisted? Is cross-table access explicit and permission-checked, with broader scripting governed separately?
- Recovery: When a formula cannot be evaluated, does the user receive an actionable explanation and a safe path to correct the data or expression?
Informat closes with “Design it like a language.” The advice follows from the reach an expression system can acquire: define its semantics, dependencies, execution contract, and capabilities as deliberately as the platform defines any other shared interface.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
