4 Habits of Source Data Sanity
There’s a moment in almost every data conversation where someone finally asks the only question that matters: okay, bad data clearly causes real damage — so what do we actually do about it?
Table of Contents
The answer usually disappoints people a little. It’s not a new tool. Not a smarter dashboard. Not some clever AI feature bolted on top of everything else. It’s four pretty unglamorous habits, applied right where data first gets typed into a system — before any dashboard, model, or person downstream even gets the chance to inherit a mistake they’d have no way of spotting. None of these habits are complicated. That’s kind of the point. Nobody needs expensive new software here. Just a team willing to treat data entry like something that actually matters, instead of disposable clerical work nobody bothers looking at twice.
Why the Fix Has to Happen at the Source
Every system sitting downstream — a dashboard, an automated workflow, an AI model pulling together a summary — processes exactly what it’s handed. None of them independently stop to check whether a number looks realistic, not unless someone specifically built that check in beforehand. Which means the only place you can reliably catch a bad entry is right where it got typed, not three steps later after it’s already shaped a target, triggered a workflow, or quietly fed into someone’s decision. That’s the whole logic behind source data sanity. Structure the entry point so an obviously wrong value either can’t get through, or gets flagged the second it tries.
Habit 1: Unit Literacy
The first habit is almost embarrassingly simple once you see it: put the unit right into the field name instead of leaving it for someone to guess.
A field just labeled “Feedstock” leaves people guessing. Kilograms? Tons? Liters if it’s liquid? A field labeled “Feedstock_In (T)” closes that question off entirely. Whoever’s typing a number in knows exactly what scale is expected, and anyone reading that number later doesn’t have to assume anything either. Sounds too small to matter — until you picture what happens without it. A feedstock figure gets logged as 20,000 in a field meant to track tons, when it should’ve been closer to 20. Nothing about the field itself warned anyone something was off, because the field never said what scale it expected. That one missing bit of context is often the entire gap between a correct number and one that’s wrong by a factor of a thousand. Fixing this costs basically nothing beyond renaming a field properly. It might be the highest-leverage, lowest-effort change a team can make.
Habit 2: Bounds Checking
The second habit is about agreeing ahead of time what a realistic range actually looks like for each parameter, then baking that range straight into the entry process — rather than hoping whoever’s typing will notice if a number looks off.
Take a shift log tracking digester level, pH, and runtime hours. Each one has a pretty obvious realistic range if you stop and think about it. Digester level somewhere between 0 and 10 meters. pH between 0 and 14 (that’s the whole scale). Runtime that can’t physically go past 24 hours in a single day.
Without any bounds checking, a log can quietly end up with a digester depth of 7,000 meters, a pH of 72, or 240 hours logged against one calendar day. Numbers that are plainly impossible the second you think about them, but easy to skim right past when they’re just one more row in a long list. A system that rejects anything outside an agreed range at the point of entry never lets these numbers travel further and quietly warp a dashboard or a target downstream. This one takes a short conversation — the team agreeing together on what range actually makes sense per field — and then turning that agreement into a simple validation rule on the form itself.
Habit 3: Data Consistency
The third habit deals with a quieter kind of mess: small formatting differences that cause a computer to treat the exact same thing as two completely different things. A date written as 24/09/2026 in one row and 24-09-2026 in another looks like a trivial stylistic difference to a person skimming the log. A system reading that same data often doesn’t see it that way at all — it might treat those as two unrelated values, which quietly breaks anything that depends on sorting or filtering by date. Same problem shows up with something as small as capitalization. “Site Alpha” and “site alpha,” typed by two different people on two different shifts, can end up logged as two separate locations as far as a system’s concerned, even though everyone involved meant the exact same place. The fix is just standardizing things. One agreed date format, used everywhere. Dropdowns for site names instead of free-text fields, where tiny spelling or capitalization differences creep in without anyone noticing. A little upfront structure saves a much bigger mess of fragmented, duplicated records down the line.
Habit 4: Complete Ownership
The fourth habit is less about the data itself and more about who’s actually responsible for it. Even a perfectly designed field — right unit, right bounds and all — eventually falls apart if nobody’s accountable for how it gets used.
This means naming an actual owner for every field that matters. Someone who knows exactly what format’s expected, who makes sure everyone entering data understands the standard (and hears about it if that standard ever changes), and who checks every so often that it’s actually being followed, instead of just assuming it’s fine because nothing’s obviously broken yet.
Ownership also catches a kind of problem the other three habits don’t really touch — a row that got duplicated by accident, or a field left blank where a name should’ve gone. Picture a reporting manager’s ID field left empty, or filled in with “N/A.” An automated review workflow depending on that field just… never triggers. No error message. Nothing obviously wrong. The gap sits there invisible until someone eventually notices a review never happened, then burns a few hours tracing it back to one missing value that should’ve taken two seconds to fill in properly the first time. An owner checking in regularly is often the only thing standing between a small gap like that and a much longer, more annoying cleanup later.
Putting the Four Together
None of these four habits is a dramatic fix on its own, and that’s sort of by design. Unit literacy stops a value from getting misread at the wrong scale. Bounds checking stops an impossible number from slipping through unnoticed. Consistency stops tiny formatting differences from quietly splitting what should be one dataset into several. And ownership makes sure someone’s actually keeping an eye on the whole thing over time, instead of assuming good habits just maintain themselves.
Put together, they’re a pretty simple sequence: structure the data properly, make sure the people entering it actually understand that structure, and check — regularly, not just the one time — that the structure’s holding up. Skip any one of those three and the other two tend to erode anyway, because a rule nobody enforces eventually just stops getting followed.
Why This Matters More Than It Seems To
It’s easy to write these four habits off as minor administrative housekeeping — the sort of thing that sounds reasonable in a training session but never quite feels urgent enough to actually act on. The problem is that every dashboard, every AI-generated summary, every automated workflow sitting on top of a dataset inherits whatever sanity (or lack of it) existed back when that data first got typed in. A beautifully built analytics system sitting on top of messy, inconsistent data doesn’t magically become trustworthy just because the system itself is sophisticated. It just produces confident, well-formatted conclusions standing on a foundation nobody actually checked.
This is more or less the thinking behind Ankashram’s data culture training — not some abstract policy document, but four specific, practical habits that decide whether an organization’s numbers can actually be trusted once they land in front of someone making a real decision. None of it needs new software. It just needs a team that treats the moment data enters a system as the moment that matters most, because everything built on top of it depends entirely on getting that one moment right.
Frequently Asked Questions
Q1.What are the 4 habits of source data sanity?
Unit literacy (building the unit into the field itself), bounds checking (agreeing on and enforcing a realistic range for every parameter), data consistency (standardizing formats so small variations can’t fragment the data), and complete ownership (naming someone accountable for each field who sets, communicates, and checks the standard).
Q2.Why fix data at the entry point instead of cleaning it up in the dashboard later?
Because every tool downstream — dashboards, AI models, automated workflows — just processes whatever it’s given, with no built-in way to judge whether a value makes sense. Catching a problem right at entry stops it from ever reaching, and quietly distorting, everything built on top of it.
Q3. Do these habits need new software or tools?
Not really. They’re mostly about structure and process — clear field names, agreed ranges, consistent formats, and someone actually owning each field. Most of this can get built into forms and spreadsheets a team already uses. No new purchase required.
Q4.What does a unit literacy problem actually look like?
A field just labeled “Feedstock” leaves the unit open to guessing. Renaming it to something like “Feedstock_In (T)” removes that ambiguity outright, which makes it a lot less likely someone enters a number at the wrong scale.
Q5.How does assigning ownership actually prevent errors?
An owner for a field knows the expected format, makes sure everyone entering data knows it too, and checks every so often that it’s being followed. Without one, even a well-designed field tends to drift out of compliance over time as new people start entering data without the full context. Does this only apply to big organizations with complicated systems? Not at all. These habits hold up at any scale — a small team’s shared spreadsheet benefits from the same structure as a large company’s operational dashboard. What changes with size is how far a bad entry can travel, not whether the underlying problem exists in the first place.