Refolk
ReferenceProcess, data, and compliance

The Record Lineage Field Reference: Thirteen Fields Behind Every Value

Look up any of thirteen lineage fields and get its definition, the question it answers, how it lies, and whether CRM history keeps it or a custom log must.

24 min readLast reviewed November 7, 2026Read as Markdown

Key takeaways

  • Native CRM history is not an audit trail: Salesforce Field History Tracking covers 20 fields per object for 18 months in the interface and 24 months via the API, and HubSpot keeps 45 revisions per contact property and 20 per company property.
  • Store observed-at separately from ingested-at, because a re-imported old CSV stamped with today's date will otherwise win a most-recent merge against a fresher value.
  • Reversing a bad enrichment overwrite needs three logged fields per value: the prior value, the overwritten-by batch id, and the ingested-at time.
  • GDPR Article 14(2)(f) requires naming the source even when the data was publicly accessible, so the source URL field carries legal weight on scraped public data.
  • Store email verification as three raw columns, status, sub-status, and domain catch-all flag, because mapping accept_all to a single verified label hides that the mailbox was never confirmed.
  • Refolk's index holds 2.7x as many US Revenue Operations profiles as Data Governance profiles, so the lineage schema will usually be designed and owned by RevOps.

This reference defines the thirteen lineage fields to store on every person and company record, so that when someone asks where a value came from, when it was true, or what it replaced, the record answers and nobody has to remember. It is written for recruiting operations, revenue operations, and anyone answerable for how the data was gathered. Look up a field, read what it proves and how it lies, and see whether native CRM history keeps it or a log of your own has to.

What is a record lineage field?

A record lineage field is a column stored next to a value that records where the value came from, when it was true, who wrote it, on what legal footing, and what it replaced. Lineage belongs to each value, not to the record, because one contact can carry an email from an enrichment job, a title from a public profile, and a phone number a rep typed in.

Most advice on field-level provenance for CRM enrichment stops at "log source and timestamp per field". That is two fields, and the timestamp is ambiguous. The thirteen fields here fall into five layers, each answering a question someone will eventually put to you:

  • Legal: were you allowed to hold this, and did you tell the person?
  • Origin: which system, page, and collector produced it?
  • Time: when was it true at the source, and when did it land in the CRM?
  • Trust: was it checked, and how far do you believe it?
  • Change: what did it replace, and which job replaced it?

The five layers of value lineage

  1. Legal
    Lawful basis, notice-sent date, retention-clock start
  2. Origin
    Source system, source URL, collector, collection method
  3. Time
    Observed-at and ingested-at, kept apart
  4. Trust
    Verification status and date, confidence
  5. Change
    Prior value and overwritten-by
Native CRM history reaches parts of the inner layers at best; the outer layers exist only in a log you build.

Design these columns once. The same columns later answer an access request, a disputed overwrite, a provenance challenge, and an audit of AI-inferred values, so you never build a separate log for each.

How far does native CRM field history go?

Native field history keeps old and new values for a limited set of fields over a limited window: Salesforce Field History Tracking covers 20 fields per object for 18 months in the interface and 24 months through the API, and HubSpot keeps 45 revisions per contact property and 20 per company property. Neither stores a source URL, an observed-at time, or any legal field.

SystemFields trackedRevisionsRetention
Salesforce Field History Tracking20 per objectUnlimited in window18 months UI / 24 via API
Salesforce Field Audit Trail200 per objectUnlimitedUntil deleted
HubSpot contact propertyAll properties45 per propertyNot stated
HubSpot company, deal, ticket, customAll properties20 per propertyNot stated

Salesforce limits that matter for lineage

  • Off by default. You switch tracking on per object and per field, up to 20 fields per object.
  • History starts at enablement. Salesforce tracks a field from the moment you turn it on. Nothing earlier exists to recover.
  • Excluded types. Custom fields of type Auto Number, Formula, Rich Text Area, and Long Text Area are not tracked. For long text over 255 characters, Salesforce records only that the field was edited, not the before and after values. Multi-select picklists also record only that a change happened.
  • No channel column. A history row holds the record, the field, the old value, the new value, the user, and a timestamp precise to the second. For an API or integration write, the only "source" is the running user.
  • Field Audit Trail. The add-on tracks up to 200 fields per object, kept until deleted, and stores archived history in FieldHistoryArchive, which is readable through the API only. One secondary source says 60 fields; the official developer documentation says 200, so check your own org's setup before planning around either number. Its HistoryRetentionPolicy setting accepts a minimum of 1 month and a maximum of 18 months, defaulting to 18.
  • Storage. Field History Tracking and Field Audit Trail data do not count against data storage limits.

HubSpot limits that matter for lineage

  • The cap counts revisions, not time. It applies to all revisions, whether made in HubSpot or via the API. A community test of one contact property with 61 versions returned exactly 45 entries, newest first.
  • Churn sets the horizon. A frequently enriched company property can exhaust its 20 revisions in weeks while a stable one keeps years of history, so "how far back" differs field by field.
  • Source labels are coarse. HubSpot tags each change with a timestamp and a source such as Workflow, User Action, or Import. Nobody has published an exact definition of each label, so do not treat it as your collection method.
  • Deleting a property deletes its history. The whole change trail goes with it.

The lineage field reference

Each field below gets a definition, what it proves, how it misleads, and where it can live. "Native" means Salesforce or HubSpot field history captures it without a custom log; for most fields the honest answer is no, or only partly.

Origin fields

FieldQuestion it answersNative history?
Source systemWhich system or feed produced this?Partly: HubSpot label only
Source URLWhich page or record, exactly?No
CollectorWho or what ran the collection?Running user only
Collection methodDirect, import, enrichment, scrape, or inferred?Coarse label in HubSpot; none in Salesforce

Source system. The named system, feed, or file a value came from: "public GitHub graph", "event attendee import", a named enrichment provider, "rep entry". It proves which pipeline to interrogate when a value is wrong. It misleads when it names the integration rather than the upstream origin: "middleware sync" tells you nothing about where the middleware got the value. Native history does not hold it; HubSpot's Workflow, User Action, or Import label is a channel, not a source.

Source URL. The address or identifier of the exact page, profile, filing, or file the value was read from, with a sub-field source_public set to true or false. It proves the value can be shown to someone else, and it carries legal weight: GDPR Article 14(2)(f) requires telling the person which source their data came from and, if applicable, whether it was publicly accessible. A public source is not one of the exemptions. It misleads when it points at a search results page or a homepage instead of the specific page. Native history never holds it.

Collector. The human, service account, or vendor job that performed the collection. It proves accountability for a value. It misleads when every vendor writes through one shared integration user, because every API write then shows the same name and the vendors cannot be told apart. Salesforce history keeps the user, so give each vendor its own integration user.

Collection method. A controlled value describing how the value was obtained, from a fixed list such as: direct from the person, file import, API enrichment, scrape of a public page, manual research, or inferred by a model or rule. It proves which obligations apply, especially whether the value is an inference. It misleads when a vendor's value was itself inferred upstream and you log it as plain enrichment. Ask each provider which of its fields are derived.

Time and change fields

FieldQuestion it answersNative history?
Observed-atWhen was this true at the source?No
Ingested-atWhen did it land in the CRM?Yes, the change timestamp
Prior valueWhat did it replace?Yes, within caps and tracked fields
Overwritten-byWhich job replaced it?User only, no batch id

Observed-at. The time the source showed this value: for a file, the file's own export date; for a page, the time you read it, unless the page states a date you have tested. It proves recency of truth, which is what any "most recent wins" merge rule should compare. It misleads in two ways. It gets silently set to the ingest time, or it gets copied from a source's last-modified signal. Search engines use a sitemap lastmod only when it is consistently and verifiably accurate; many CMSs and CDNs send no Last-Modified header at all, and some caching setups strip it or return a static value whatever changed. For profiles, repositories, and filings, which last-modified fields are reliable is not established, so test a sample against known changes before trusting any of them. Add a sub-field, observed_at_basis, recording whether the time came from the source, a file export date, or the moment of collection.

Ingested-at. The time the value was written to your system, to the second. It proves the order of writes and lets you find everything one job touched. It misleads when read as if it were observed-at: re-import an old CSV and every value gets today's ingested-at. Native history holds it, because this is what the history timestamp is.

Prior value. The value immediately before this write. It proves what a rollback would restore. It misleads when history has been truncated: past HubSpot's 45 or 20 revisions, beyond 24 months in Salesforce, or on long text and multi-select picklists where only "it changed" is kept. Native history holds it within those limits.

Overwritten-by. The batch or job identifier of the write that replaced the prior value. It proves which job to reverse, and lets you reverse all of that job's writes at once instead of record by record. It misleads when the "job" is just a user name shared by several integrations. Native history does not hold it. An enrichment audit trail with previous-value rollback needs three things per write: prior value, overwritten-by, and ingested-at.

Trust fields

FieldQuestion it answersNative history?
Verification statusWhat did the checker return?Only if stored as its own tracked field
Verification dateWhen did the check run?Only if stored as its own tracked field
ConfidenceHow far do you believe it?No

Verification status and date. One field with two parts: the raw result of a check in the checker's own vocabulary, and the date the check ran. For email, one widely used verification API returns a status of valid, invalid, catch-all, unknown, spamtrap, abuse, or do_not_mail, plus a sub-status. Its sub-status accept_all means the domain was vetted and historically delivers, and the address comes back as valid; its catch-all status means the domain is not on the allow-list and deliverability cannot be confirmed. It also reports a separate domain-level catch-all indicator, so an address can read valid or invalid while the domain flag says catch-all. Store status, sub-status, and domain flag as three raw columns. The "unknown" status covers sub-statuses such as greylisted, antispam_system, timeout_exceeded, and forcible_disconnect, which are worth a retry rather than a suppression. Status vocabularies for phone and firmographic checks were not verified for this reference; read your provider's documentation before mapping them. The status proves what was checked; it misleads when collapsed into an umbrella "verified" label. The date misleads when a sync re-stamps it without re-running the check.

Confidence. Your own score for how far to believe a value. There is no standard scale, so it proves nothing on its own; it is useful only alongside the rule that produced it. It misleads when scores from different providers or scoring versions are compared as if they shared a scale. Store a scoring_version sub-field next to it.

Legal and retention fields

FieldQuestion it answersNative history?
Lawful basisOn what legal ground is it held?No
Notice-sent dateWhen was the person told?No
Retention-clock startFrom when does the deletion clock run?No

Lawful basis. The legal ground recorded for processing this value. It proves the decision was made at collection, not reconstructed later. It misleads when set once on the record and inherited by values collected afterwards under different circumstances.

Notice-sent date. The date the Article 14 notice actually went to the person. The deadline is one month after obtaining the data, or the first communication if you use the data to contact them. It proves the timing was met. It misleads when it records the date a sequence was scheduled rather than the date a message was sent.

Retention-clock start. The date from which this value's retention limit counts, with a sub-field naming its retention category. Article 30 requires the record of processing activities to state, where possible, the envisaged time limits for erasure of the different categories of data, but Article 30 works at the level of the processing activity, not the row. Without a per-value clock start, nothing enforces the category limit on actual data. It misleads when a sync that re-collected nothing resets it, keeping old data alive indefinitely.

Two companion flags

  • Inferred flag. Marks values derived by a model or rule rather than read from a source. Under California's Delete Act, data brokers in scope must access DROP, the state's deletion request platform, at least once every 45 days and delete all associated personal data including inferences. An unflagged inference survives that deletion.
  • Suppression record. A minimal record that outlives the deleted one. Brokers must keep deleting newly collected data about people who submitted deletion requests on the same 45-day cycle, and the fine is $200 per deletion request per day of failure. Without a suppression record, the next enrichment run quietly re-creates the person.

Which fields fit in native history and which need a custom log?

Native history can hold prior value and ingested-at for a short list of stable, contested fields; everything else, and every high-churn field, belongs in an external append-only log. An append-only log is a table you only ever insert into, never update or delete from, so the next job cannot overwrite the history of the last one.

Where each field's history should live

High dispute or legal weightLow dispute or legal weight
Stable and contested
Spend a native tracked slot and mirror every write to the external log
Churning and contested
External append-only log, synced faster than the revision cap fills
Stable and minor
Native history alone is acceptable
Churning and minor
Log batch id and prior value externally; accept native roll-off
Low write churnHigh write churn
Native history is enough only for fields that change rarely and that nobody is likely to dispute.

What the platforms themselves support:

  • Salesforce stores standard history in each object's history object and Field Audit Trail history in FieldHistoryArchive, API only. Neither counts against data storage.
  • HubSpot staff have recommended that integrators capture revisions as they occur and sync them to an external system, so that when a property passes its 20-revision limit the history still exists elsewhere.
  • Sync cadence follows churn. The external log has to pull at least as often as your fastest-churning property could exceed its cap. If a property changes more than 45 times between syncs, the earlier changes are gone and the API cannot recover them.
  • Cost is not established. Row volume and cost per million records for append-only lineage tables are not published anywhere I trust. Measure a week of your own write volume before sizing storage.
A history table tells you who wrote a value and when, never when the value was true.

Who owns the lineage schema?

In most organisations, revenue operations owns it rather than a dedicated data governance team: Refolk's index holds 2.7x as many US profiles with Revenue Operations titles as with Data Governance titles. That is a derived ratio, so read it as a signal about who will be in the room, not proof.

2.7x
US Revenue Operations profiles per Data Governance profile in Refolk's index
1,394 Revenue Operations profiles against 517 Data Governance profiles; a derived ratio, best read as a signal.
Segment in Refolk's indexValueNote
US, Revenue Operations titles1,39460% "RevOps Manager" in a sample of 25
UK, Revenue Operations titles23980% "RevOps Manager" in a sample of 25
US, Data Governance titles517Comparison base
US RevOps to Data Governance2.7xDerived
US to UK RevOps5.8xDerived

The samples are only 25 profiles each, but in both countries the title concentrates at manager level. In practice that means the person designing the lineage schema is often the same person running the CRM day to day, with no separate governance reviewer. Plan for that: write the field definitions down so a privacy lead can review them asynchronously.

The skill most teams lack is a Salesforce admin who has actually configured Field Audit Trail and knows which 20 or 200 fields to spend slots on. Finding one through job boards is slow because the experience rarely appears in a title. Refolk lets you ask for that experience directly in plain English and get named people back.

How to build the lineage schema, step by step

Build the schema in seven steps: inventory sources, audit native capacity, define the fields, choose storage, instrument the writers, wire the regulatory clocks, and drill a restore. No public source documents how long each step takes, so set your own estimates after step 2.

The sources disagree on order. Privacy guidance puts source mapping first; CRM guidance starts from tracking configuration. I run steps 1 and 2 in parallel, because Salesforce history begins only when a field is switched on and every day of delay is a day of history you will never have.

Building the lineage schema

  1. Inventory every non-direct source
    The privacy lead and ops map each source that did not come from the person and write its Article 14 description. Done when every source has a name and a public or non-public flag.
  2. Audit native history capacity
    The CRM admin counts tracked fields per object against the cap of 20 and lists the excluded field types. Do it early, because history starts only at enablement.
  3. Define the lineage schema
    The ops lead writes one definition row per lineage field, from source system through retention-clock start. Done when each has a type, allowed values, and an owner.
  4. Choose append-only storage
    Data engineering stands up an external insert-only log, synced at least as often as the fastest-churning property could exceed its revision cap.
  5. Instrument every writer
    Integration owners make every enrichment, import, and API job stamp a batch id, its own integration user, and the raw vendor codes.
  6. Wire the regulatory clocks
    Privacy records the notice-sent date within one month and, if in scope, processes DROP deletion pulls every 45 days.
  7. Run a restore drill
    Ops exports a property's history and reimports the prior values on a sandbox, reversing one whole batch. Field Audit Trail archives sandbox history after one month, so drill promptly.

The log table below is the schema from step 3 in a form you can hand to data engineering.

Append-only lineage log, one row per value write
lineage_log
  record_type               -- person | company
  record_id
  field_name
  new_value
  prior_value               -- value immediately before this write
  overwritten_by            -- batch id of this write, which replaced prior_value
  source_system             -- named system, feed, or file
  source_url                -- exact page, profile, filing, or file
  source_public             -- true | false (Article 14 flag)
  observed_at               -- when the source showed this value
  observed_at_basis         -- source_stated | file_export_date | collection_time
  ingested_at               -- when this row was written, to the second
  collector                 -- distinct integration user or named person
  collection_method         -- direct | import | api_enrichment | scrape | manual | inferred
  is_inferred               -- true | false
  lawful_basis
  notice_sent_at
  verification_status_raw
  verification_substatus_raw
  verification_domain_flag_raw
  verified_at
  confidence
  scoring_version
  retention_category        -- ties back to the processing record
  retention_clock_start

Rename columns to your warehouse conventions; keep every raw vendor code as its own column.

Step 1 produces one entry per source. This is the shape I use, filled in for a public source.

Source inventory entry
Source name: Public GitHub graph
Public source: yes
Article 14(2)(f) wording: "Your name, username and public repositories were collected from your public GitHub profile."
Fields it populates: name, username, primary languages, public email where shown
Collector identity: dedicated integration user for this source only
Collection method: scrape of a public page
Lawful basis: as recorded by the privacy lead for this activity
Notice route and deadline: within one month of collection, or at first contact if earlier
Retention category: candidate sourcing data

One entry per non-direct source; the Article 14 wording is what the notice will say.

How lineage goes wrong: failure modes and false positives

Lineage fails quietly: the columns exist, they are populated, and they still answer the question wrongly. These eight failures account for most of the damage, and each has a local check.

  1. Observed-at collapsed into ingested-at. A re-import of an old CSV stamps today's date, and the stale value wins a most-recent merge against a fresher one. What it looks like: a batch of values with identical observed-at and ingested-at times to the second. Check: compare observed-at against the file's own export date.
  2. Trusting a source's last-modified date. CDN-cached or build-stamped dates look fresh but are not. What it looks like: a bulk-stamp pattern, such as 86% of a site's pages carrying one date. Check: plot the distribution of source dates per domain before using any of them as observed-at.
  3. Umbrella verification label. Mapping accept_all to "verified" makes an address look confirmed when the mailbox never was. What it looks like: a verified column with no sub-status beside it. Check: confirm the raw sub-status column survives every sync into the CRM.
  4. Assuming native history is complete. One guide claims HubSpot does not limit how many changes it logs per field; the official knowledge base contradicts it with the 45 and 20 caps. Check: count the history entries returned for your highest-churn property.
  5. System-context writes missing from history. One older source says automation running under a user without edit permission is not tracked. This is unverified for current releases. Check: run a test flow on a tracked field and inspect the history yourself.
  6. Integration user as collector. Every API write shows the same user, so you cannot tell which vendor wrote a value. Check: give each vendor its own integration user and require a batch id on every write.
  7. Inferred values unflagged. DROP deletion covers inferences; without an inferred flag, derived values survive a deletion. Check: query for values with no source URL, which are usually inferences or rep entries nobody labelled.
  8. Article 30 retention treated as a per-record clock. The processing record states limits by category, but nothing on a row enforces them. What it looks like: a documented retention period and no data ever deleted. Check: count records past their category limit using retention-clock start.

Which lineage fields answer an access request, a dispute, or an audit?

Each of the common challenges reads a different subset of the same columns, which is why one schema serves all of them. Native history alone answers none of them fully.

QuestionFields you readNative history enough?
Access request: where did you get my data?Source system, source URL, notice-sent dateNo
Disputed overwritePrior value, overwritten-by, ingested-at, observed-atOnly inside cap and window
Provenance challengeSource URL, observed-at, collector, collection methodNo
AI-inferred value auditCollection method, inferred flag, confidenceNo
Deletion requestSuppression record, inferred flag, retention-clock startNo

People sourced through Refolk get logged the same way as any other collector: Refolk as source system, the public profile URL as source URL, and the date of the search as observed-at unless the profile states a later date you have tested.

The disputed overwrite is the case people most often get wrong, because the restore path closes silently. HubSpot lets you export a property's history and import the old values back. In Salesforce, Data Loader or the queryAll() API retrieves history 18 to 24 months old; beyond 24 months it is gone. Once native history has rolled off, there is no documented restore procedure without an external log or backup.

Reversing a bad enrichment overwrite

  1. Find the job
    Identify the overwritten-by batch id behind the disputed values
  2. Scope it
    Pull every row that batch wrote, bounded by ingested-at
  3. Compare truth
    Check observed-at on prior and new values; keep whichever was true later
  4. Restore
    Reimport the prior values as a new batch with its own id
  5. Record it
    Log the restore so the reversal is itself traceable
A rollback is only possible when each write logged its prior value, its batch id, and its ingested-at time.

How to keep the lineage schema current

The schema stays correct only if you re-check the mechanisms it depends on, because platform caps, provider vocabularies, and regulatory cycles change without notice. Put these on a calendar rather than waiting for a dispute to reveal the drift.

  • Revision caps. Re-read the HubSpot property history documentation and the Salesforce field history pages, then count history entries on one high-churn property to confirm the cap your sync cadence assumes.
  • Tracked-field allocation. Review which 20 fields per object hold native tracking slots whenever a new field becomes disputed or legally sensitive.
  • Verification vocabularies. Re-read each checker's status code documentation and diff it against your allowed-values list; a new sub-status that maps to nothing is a silent umbrella label.
  • Regulatory cycles. If you are in scope of the Delete Act, confirm the DROP pull cadence is still 45 days on the regulator's data broker page. Independent audits of data brokers are required every three years, and your lineage log is what an auditor will read.

Before calling the lineage schema done

  • Every non-direct source has an Article 14 description and a public or non-public flag.
  • The tracked-field count per Salesforce object is at or under 20, and the chosen fields are written down with a reason each.
  • Observed-at and ingested-at are separate columns, and observed-at has a recorded basis.
  • Every integration writes as its own user and stamps a batch id on every value.
  • Verification is stored as raw status, raw sub-status, domain flag, and check date.
  • The external log syncs faster than the fastest-churning property can exceed its revision cap.
  • Inferred values carry a flag, and deleted people leave a suppression record behind.
  • Each value has a retention category and a retention-clock start.
  • A restore drill has reversed one whole batch on a sandbox, and the reversal is logged.

Questions practitioners ask

Is Salesforce field history tracking enough for an audit trail?

No. Field History Tracking is off by default, covers at most 20 fields per object, and keeps data for 18 months in the interface or 24 months through the API. It records old value, new value, user, and timestamp, but no source URL, observed-at time, or legal fields. Field Audit Trail extends coverage to 200 fields kept until deleted, but it still stores no provenance beyond the user who made the change.

How many revisions does HubSpot keep for each property?

HubSpot keeps up to 45 revisions per contact property and up to 20 per company, deal, ticket, and custom object property, counting changes made in the app and via the API alike. Older revisions drop off once the cap is reached. A community test found exactly 45 entries returned after 61 versions. Deleting a property also deletes its entire change history.

What is the difference between observed-at and ingested-at?

Observed-at is when the value was true at its source; ingested-at is when it was written into your CRM. They diverge whenever old data arrives late, such as a re-imported export file. If you store only ingested-at, an old value can carry today's date and beat a fresher value in any most-recent-wins merge rule.

Do I need to record the source if the data came from a public profile?

Yes. GDPR Article 14(2)(f) requires telling the person which source their data came from and whether it was publicly accessible, and a public source is not one of the exemptions. Store the specific page or profile URL plus a public or non-public flag for every value that did not come from the person directly.

Can I roll back a CRM field after a bad enrichment overwrite?

Yes, if the history still exists. HubSpot lets you export a property's history and reimport the old values, and Salesforce history 18 to 24 months old can be pulled with Data Loader or the queryAll() API. Once revisions pass the cap or the window, no documented restore path exists without an external log holding the prior value, batch id, and ingested-at time.

Should email verification status be stored as one field or several?

Several. Store the checker's raw status, its raw sub-status, and its domain-level catch-all flag as three separate columns, plus the date the check ran. A single verified field hides the difference between a domain that historically delivers and a mailbox that was never confirmed, and that difference is exactly what a deliverability dispute turns on.

Try it on the search you came here for

Stop building boolean strings. Just describe the person.

Type one sentence. I plan the search, read GitHub, public LinkedIn and Crunchbase records, and the open web as it is right now, and hand back a ranked list with the reason next to every name.

  1. 01Describe them

    One plain sentence. Role, city, stack, stage, whatever matters to you.

  2. 02I read the web live

    GitHub, public LinkedIn and Crunchbase records, the open web. Not a database that went stale last quarter.

  3. 03You read the shortlist

    Ranked, with the reasoning under every name. Open a profile, ask a follow-up, narrow it down.

  • No boolean, no filters, no seat to buy. One box.
  • Read at search time, so a profile updated yesterday counts today.
  • Every step visible as it runs, every name with its reason.

500 free credits on sign-up. No card, no demo call. See real searches.

Read next