Catch bad data at the source, and know the rule behind it
The wrong IBAN entered in March, found by payroll in December. Bad data isn't caught when it's entered, it's caught when it breaks something, and in payroll that means someone gets paid wrong. Popay's Validation Framework checks every transaction the moment it happens. And it goes further than integrity: it knows the rules, the legislation and internal policies that make up your business logic, and guides your people to apply them, not just flags a broken field.
Found too late
Data problems are cheap to fix at the keyboard and expensive everywhere else. This is what waiting costs.
Not every issue is equal, the framework knows the difference
A rigid block breeds workarounds; no validation breeds bad data. Three severity levels let each rule respond in proportion to what's at stake.
Cannot proceed
The transaction stops until it's fixed. No bypass. For data that must be right: an invalid IBAN, a missing national number.
Proceed with awareness
Flagged, but the user can continue knowingly. For data that should be there but isn't always available yet.
Awareness only
A gentle prompt, no obstruction. For nice-to-have data or a nudge toward best practice.
It knows the rule, whatever its origin
Most validation only checks that data is well-formed. The Validation Framework goes further: a rule is a rule, wherever it comes from, and it applies all three at the point of entry.
Data integrity
Format, completeness, plausibility: a valid IBAN, a national number that checks out, a required field actually filled.
Legislation
Statutory rules: mandatory data, legal minimums, country payroll requirements, so what the law expects is enforced, not left to someone remembering it.
Internal policy
Your own rules: company policy, sector accreditation, governance standards, encoded once and applied the same way every time.
And when a rule fires, it doesn't just say "no". It tells your people which rule, why it applies, and what to do about it, so the framework helps your organisation understand and apply the rules, not just obey them. The compliance posture behind those rules, vetting, audit-readiness, lives in Vetting & compliance; here, the rules meet the data, at the keyboard.
Validated at the source, on every transaction
Every user action is a transaction: a field edited, a hire submitted, a document uploaded, a leave request raised. A rule attaches to any transaction and fires the moment the action happens, at the point of entry, so the error is caught by the person who can still fix it.
Rules are set per transaction and per organisation: what's blocking on a hire may be irrelevant on an internal move. And the feedback is plain language pointing to the fix, not a cryptic code.
Right rule, right moment. Caught where it's entered, by who can fix it.
One engine, everywhere
The Validation Framework is one of two capabilities that span the whole platform. Where Employee lifecycle connects events to action, it validates: the same engine checking a hire flow, a payroll transfer, a document upload, a leave request and an asset assignment.
One framework instead of a different, half-remembered set of checks in every corner of the system, so quality stops being patchy by module.
One framework, every transaction. Not a patchwork of checks.
Your business logic in one place, ready for AI
Clean data is the start. What the framework really holds is your business logic: the rules that decide what's valid, required or compliant. Today that logic tends to be scattered: hardcoded in one system, kept in a spreadsheet, rebuilt in every integration, remembered by one expert. Held centrally, there's a single answer, and everything reads from it.
That's a deliberate choice for what's coming. Business logic held centrally and exposed cleanly is consumable by APIs and AI agents, so a person at the keyboard, a system pushing data, and an agent acting on your behalf all apply the same rules, the same way.
Where agents and integrations get the rules is here; keeping their actions compliant and auditable is Vetting & compliance.
One home for the rules. Consumed by people, APIs and agents alike.
Configured to your reality, manageable after go-live
Popay sets up the initial framework with you during implementation. After go-live, you adjust it yourself, add a rule, change a severity, retire one, through a validation rule editor. No new implementation project every time your reality shifts.
And the rules that track the law aren't yours to chase: legislative rules, especially payroll, across countries, are maintained centrally and kept current, so the framework stays right as the law moves. Your integrity and policy rules stay yours to shape.
Popay sets the framework. You keep it fitting.
Trust the data the whole platform runs on
Every module reads the same record: payroll, reporting, compliance, the lifecycle engine. When quality is enforced at the source, in proportion, and against the right rule on every transaction, the record stays trustworthy by default. The error that would have surfaced in December simply never gets saved in March.
Nowhere does that matter more than payroll: get the data right at the keyboard and the run is right the first time, no corrections, no wrong pay, no compliance scramble after the fact.
Caught at the source. Not discovered at the end.
Part of Core HR
The Validation Framework is the guardrail on the Core HR record, active wherever data is entered or moved. It works closely with:
Stop finding errors at year-end
Validate every transaction at the source, in proportion to what's at stake, and keep the record the whole platform runs on trustworthy by default.
Request a demo →