When OpenMetadata PII auto-classification is worth setting up
OpenMetadata PII auto-classification is worth setting up when a data team has many tables and no reliable inventory of personal data. The feature suggests PII tags by matching column names and inspecting sampled values. Its output is a set of suggestions for a steward to review, and it is not a compliance determination. A team in this position usually knows that customer records sit in several warehouses and BI extracts, but cannot say with confidence which columns hold names, contact details, identifiers or account numbers. Manual tagging can work for a small estate, but it depends on whoever built each table remembering to label it, and that memory fades as the catalog grows.
Three triggers justify the setup effort. The first is an upcoming access review, where reviewers need to know which datasets expose personal data before they decide who should keep access. The second is retention work, because a retention period can only be applied to data you have located. The third is privacy record-keeping, where your processing records need a current view of which systems hold personal data. A fourth signal is practical: when new connectors and tables are added faster than stewards can tag them by hand, the backlog of untagged columns grows without anyone noticing.
The feature is less useful when the estate is small enough that a steward can review every table in a sprint, or when the team has not yet agreed what counts as personal data for its own purposes. Suggestions depend on the classification rules in place and on the profiling run against each table, so a catalog with few profiled tables will show few suggestions. Before committing, confirm in your OpenMetadata version which classifications ship by default, how profiling is scheduled for the tables you care about, and whether PII classification runs during ingestion or as a separate job. The 2.0 release notes state that Dynamic Sampling became the profiler default, so check which sampling method your deployment actually uses.
Decide the scope before enabling anything. Pick the domains or connectors where the first review will happen, name the stewards who accept or reject suggestions, and record which tags are allowed to drive access decisions. Ask the team running the deployment to confirm which permissions the ingestion service account needs to read sample values, and whether any sample values are stored or displayed in the catalog. Those answers decide whether the feature is worth running on your most sensitive sources at all.
Which classification approach fits each data set
This table compares the three ways to find personal data in OpenMetadata and the sampling setting that governs scanned values. Read each column for what the approach sees, where it errs and how much personal data it exposes. Combine them where their strengths offset each other, and measure precision on your own sample tables before you trust any setting.
| Factor | Column-name rules | Sample-data scanning | Manual tagging only |
|---|---|---|---|
| What it reads | Column names and, where configured, data types, matched against patterns such as email or phone labels. | Actual values in sampled rows, matched against recognizers for patterns such as email addresses or national IDs. | Whatever the data owner knows or inspects, usually schema, documentation and sample context. |
| Main false positive risk | Names such as contact_id or notes_ref match patterns but hold no personal data. | Codes, test values or reference numbers that look like identifiers. | Low for tagged columns, but reviewers may tag inconsistently. |
| Main false negative risk | Abbreviations, misspellings or neutral names such as ref_2 that hold personal data. | Personal data in free text, rare formats or rows outside the sample. | Columns whose owners lack context, and tags that drift as schemas change. |
| Privacy exposure | Low, since it reads metadata and no personal values leave the source. | Higher, since values are read and may appear in profiling output. Confirm retention and access settings. | Lowest automated exposure, though reviewers may open data to decide. |
| When it fits | First pass on wide warehouses and fast checks on schemas with consistent naming. | Columns with neutral names that may hold personal data, once precision is measured on sample tables. | Small, high-sensitivity sets, final sign-off on automated tags and domains where automated results fail precision checks. |
| Sampling setting (full, sampled or dynamic) | Not applicable, no values are read. | Full scans every row, sampled reads a fixed subset, dynamic sizes the read per table. Full suits small tables, dynamic suits large, varied ones. | Not applicable, the sampling setting does not apply. |
How OpenMetadata PII auto-classification finds personal data
OpenMetadata reaches a personal data suggestion through two separate signals, and neither one settles the question alone. The first is name-based matching. Rules compare table and column names against patterns linked to personal data, so a column named email_address or date_of_birth becomes a candidate before any values are read. This signal relies only on metadata the connector has already ingested. Its blind spots are predictable: a column called ref_2 may hold a phone number and never match, while a column called customer_email in a sandbox table may match even when it holds only test values. Treat name matches as a list of places to look first, and check each one against the data itself.
The second signal is content-based inspection. After a profiler run has sampled values from a table, recognizers examine those values for formats that suggest personal data, such as email-shaped strings or identifiers with a recognizable structure. A column with an uninformative name can still be flagged this way, which is the main reason to enable it. The limit is that content inspection only sees what the profiler sampled. A table that is never profiled cannot receive a content finding, and a column whose sample is empty or unrepresentative can be missed. Before relying on either signal, confirm in the documentation for your version which recognizers ship, which are enabled by default, and how the profiler chooses its sample. OpenMetadata 2.0 made Dynamic Sampling the profiler default, so the sampling behavior you test may differ from older releases.
A finding is stored as a suggested classification on the column, under a PII-related classification, and it stays a suggestion until someone acts on it. The record shows the column and the classification, so a reviewer can decide what happens next. A reviewer confirms the suggestion, which turns it into an applied classification on the column, or rejects it, which removes the suggestion. Confirm in the documentation whether a rejected suggestion can reappear after a later profiling run, whether the record keeps the reviewer's identity and the date of the decision, and which roles may confirm or reject. Those answers determine whether your records can show who approved each personal data label.
Plan the review step before you enable detection across a whole schema. Decide who holds review rights, how many suggestions a reviewer can work through in one session, and what evidence you need to keep when a suggestion is rejected. Run a pilot on one schema, then compare the suggestions with a manual review of columns you select independently of the tool. Look for false positives and for missed columns, since missed columns are the ones that create unmanaged exposure. Finally, remember that a classification is a catalog record. It describes where personal data is held, but access to the data itself is still controlled in the source systems, so the catalog and those controls need to be reviewed together.
How to tune confidence without flooding reviewers
Confidence tuning is less about finding one correct setting and more about controlling how many candidate tags reach a person. The five levers below interact: a loose rule in a wide scope can create the same flood as a missing exclusion. Change one lever at a time, rerun it on a fixed sample set, and compare the tag counts and reviewer decisions before widening rollout.
Enabled rules and recognizers
Each enabled rule or recognizer decides which patterns can produce a PII tag. Column-name rules catch fields such as email or phone labels, while sample-data recognizers match values inside the column. Disabling a recognizer that matches a common format, such as a numeric identifier used for orders, lowers noise but can hide actual personal data in fields that use the same format. Enabling broad value patterns does the opposite. Test each change against a labeled sample set that includes both matching and non-matching columns, and confirm which recognizers your version exposes before you plan changes.
Sources and schemas in scope
Scope decides which services, databases and schemas the scanner reads. A wide scope that includes staging copies, archived schemas or vendor-loaded tables multiplies the same column names and sends duplicate tags to reviewers. Narrowing scope to production-owned schemas reduces volume but leaves gaps if personal data is copied into analytics or sandbox schemas. Check how your version filters at service, database and schema level, and confirm that the filter applies to profiling as well as metadata ingestion. Run the same sample set against each scope to see which tags disappear.
Exclusions for known false positives
Exclusions remove tables, columns or value patterns from classification. They suit known false positives, such as a product code column that matches an identifier format, and system tables owned by a loader. The risk is an exclusion written too broadly, for example on a column name that is also used for customer data in another schema, which silently drops personal data from review. Keep each exclusion tied to a named owner and a reason, and review them when schemas change. Test each exclusion by listing the fields it hides and checking them against the sample set.
Review queue staffing and routing
The review queue is where tuning succeeds or fails. Decide who owns each domain's queue, how many reviewers the expected volume needs, and what a reviewer may approve without a second person. A queue with no owner accumulates unreviewed tags, which teams then treat as approved or ignore. Route tags by data owner or domain so reviewers see the context they need to judge them. Ask your OpenMetadata administrators to confirm which review and approval states your version supports, and simulate queue load on the sample set before widening rollout.
Confidence thresholds and match scores
A confidence setting decides how strong a match must be before a tag is proposed for review or applied. Set it too low and common formats flood reviewers with weak candidates. Set it too high and genuine personal data stays untagged because its column name is unusual or its values are sparse. Threshold values and their scale vary by version and by recognizer, so confirm the available settings in your release and record the values you chose. Change one threshold at a time and compare the sample set's tag counts and reviewer decisions before and after.
Mapping PII tags to confidentiality tags
A personal-data tag and a confidentiality label answer different questions. A PII tag records what kind of personal information a column probably holds, such as an email address or a national identifier. A confidentiality label records how restricted the data must be and who may see it. Security and access teams usually work from the second question, using a short, approved scale of levels. OpenMetadata's auto-classification produces the first kind of output from column-name rules and sample-data scanning, so the mapping from personal-data categories to your internal levels is a governance decision that has to be made deliberately. Write it down before any automated tag reaches a policy engine, a data-sharing workflow or a retention job.
Build the mapping as a table with three columns: the PII category as OpenMetadata names it in your version, the internal confidentiality level it corresponds to, and the rationale for that level. Keep the number of levels small enough that data owners can apply them consistently. Direct identifiers and government identifiers often need the strictest handling, while some indirect categories may justify only a moderate level until they are combined with other fields. The approval should come from the data protection or privacy owner together with the owner of the access model, with the catalog administrator maintaining the entries. Record each approved version with its date, approver and reason for change, and keep earlier versions so that past classifications can be explained during an assessment.
The main risk is that an automatic mapping turns a detection into an access decision. If a column-name rule or sample scan labels a column as a sensitive category, and the mapping then assigns a restrictive confidentiality level, downstream tools that read that level may hide a table from analysts, block a sharing request or shorten retention. A false positive then has operational consequences. Illustrative example: a column named contact_ref that a sample scan tags as an email address could move an entire dataset into a restricted level without anyone reviewing it. Confirm in your version whether tags applied to a column propagate to its table, dashboards or glossary terms, and whether any policy in your access layer reads classification tags directly.
Place a review step between the automatic tag and any mapped label that drives access or retention. In practice, auto-applied PII tags should land in a queue owned by the data steward, who confirms or rejects each one, and only confirmed tags should be eligible for mapping. Mapped confidentiality labels should then be applied through a separate, versioned step that a second person approves. Test this workflow on one schema before enabling propagation across the catalog, and track how many suggestions are rejected, since that rate shows how far the detection rules can be trusted. Before designing the workflow, check how review states and tag propagation behave in your OpenMetadata version and document the answer.
Setting up OpenMetadata PII auto-classification in order
This sequence takes PII auto-classification from one pilot source to a reviewed and tuned rule set, then to a decision on wider rollout. Each step ends with a check, so the team knows what the pilot has proven before it adds sources or links PII tags to confidentiality tags.
Confirm the deployment and version
The platform team confirms how OpenMetadata is deployed (Kubernetes, bare metal or Docker for a trial) and which release is running, then checks the prerequisites for that deployment in the documentation for that version. If the team is moving to OpenMetadata 2.0.0, which was released on August 24, 2026, it inventories custom ingestion images, because 2.0 moved ingestion images to Python 3.12 and Apache Airflow 3.3.0 and those images may need rebuilding. Confirm the exact settings for your version in the docs. Done when the version, deployment mode and ingestion image plan are written down and signed off by the platform owner.
Connect a pilot source
A data engineer connects one warehouse or database that holds a known mix of personal data, such as customer or employee tables, using the documented connector for that system. Choose a source the team understands well, so reviewers can judge false positives accurately. If the connector or its ingestion image was built for an earlier release, rebuild it and run a test ingestion before relying on it. Confirm the connector's documented scope and authentication method for your version. Done when metadata from the pilot source appears in the catalog and a test ingestion completes without errors.
Define the classification scope and tag hierarchy
The governance lead decides which schemas, tables and columns the pilot covers and which PII tags it will use, such as categories for direct identifiers, contact details and financial data. Write the tag hierarchy and name an owner for each tag before any scan runs, so every suggestion has a clear reviewer. Keep the first scope narrow enough that a reviewer can check each category thoroughly. Done when the scope and tag list are approved and recorded, and each tag has a named owner who will review its suggestions.
Enable profiling and sampling for the pilot
The data engineer turns on profiling for the pilot schemas and sets the sampling approach. OpenMetadata 2.0 made Dynamic Sampling the profiler default, so confirm whether the pilot keeps that default or sets a fixed sample size in the documentation for your version. Sampled values are read during the scan, so the privacy lead should record what is read, where results are stored and who can view them. Sampling reduces exposure but can miss personal data that appears only in unsampled rows. Done when the sampling setting and its privacy note are documented and accepted by the privacy lead for the pilot.
Run the classification scan
The data engineer runs the classification job on the pilot scope and checks that it completes for every table in that scope. Column-name rules and sample-data scanning both produce suggestions, which are held as suggestions waiting for review in the catalog. Keep the run log and a list of tables that failed or were skipped, with the reason for each. Done when the run finishes, every failure is explained and the number of suggestions per table is recorded for review.
Review a sample of suggestions
A data steward reviews a sample drawn across tables, column types and tags, and marks each suggestion as correct, a false positive or uncertain. Include both high and low confidence suggestions so the team can see where the rules fail. Log every false positive with its column name, the sample pattern and the rule that produced it. Done when the sample review is complete and false positives are recorded for each tag in the review log, which becomes the baseline for tuning.
Tune rules and confidence thresholds
The data engineer and steward adjust column-name rules, sample-data patterns and confidence thresholds for the tags with the most false positives, then rerun the scan on the same pilot scope. Change one group of settings at a time so each effect is visible in the log. Check tags that now miss columns the steward confirmed earlier, because lowering a threshold can add false positives while raising it can drop confirmed matches. Done when a rerun on the same sample shows fewer false positives and no loss of confirmed matches.
Decide on mapping and wider rollout
The governance lead decides whether PII tags should map to confidentiality tags, which classifications those mappings feed and which sources come next. Mapping changes what downstream users see, so data owners and the security team should approve it before it goes live. Confirm the mapping behavior and rollout approach in the documentation for your version before extending it. Done when a written decision covers the mapping, the rollout order, an owner for each new source and the review cycle that keeps the tags current.
The sampling privacy trade-off in PII scans
Content scanning only works if the scanner can read values, so a PII scan that inspects column contents stores a piece of the personal data it finds. In OpenMetadata, sample rows pulled during profiling and scanning are kept in the catalog's metadata store, and sample values can also reach the search index. The catalog therefore stops being a place that only describes personal data and starts holding copies of it, with the same exposure, retention and access questions that apply to any copy. Before you enable content scanning on a connector, confirm where OpenMetadata writes sample values in your deployed version, whether those values are indexed for search, and how long they remain after a table is deleted or a scan is rerun.
Sample size and sampling method move detection quality and exposure in opposite directions. A larger sample gives the classifier more chances to see a personal value in a sparse or mixed column, which improves recall, but it also copies more personal records into the catalog. A smaller sample lowers exposure and can miss personal values that appear in only a small share of rows. Method matters as much as size. A sample taken from the first rows returned can reflect load order, so later records may never be inspected, while a random sample spreads the read across the table. Test any size and method against a labeled set of your own columns, and record the results for each table group so the decision can be reviewed later.
OpenMetadata 2.0.0 was released on August 24, 2026, and it made Dynamic Sampling the profiler default. That changes what a scan reads for any team that has not pinned its own sampling configuration. Before you upgrade, or before you enable PII scanning on a new connector, confirm what Dynamic Sampling does for your tables: how it chooses rows, whether the choice is the same for every table or varies with table size, and whether the same sample feeds the PII scan or only the profiler. The OpenMetadata 2.0 release notes are the starting point, but the answer should come from a test run on a non-production copy of your data. Record the sampling settings in the scan configuration so that a later upgrade cannot change them without someone noticing.
Decide per data class whether content sampling is allowed at all, before you choose any sample size. Column-name rules can flag many personal fields without reading a single value, so a class such as health or payment data may be limited to name-based detection, while content scanning is reserved for classes where the exposure has been accepted in writing. Record that decision with the owner of each domain, and name who approves exceptions. Then decide who can see sample rows. Limit sample visibility to the data stewards and security staff who must review classifications, check that catalog roles and search permissions apply the same restriction to sample values, and test this with a user who holds only a lower-privilege role. Ask the implementation team to show that test as part of acceptance.
Security and operational considerations for PII scans
PII scans create a second copy of personal data in the metadata layer: sampled values, classification results and the tags that drive downstream access decisions. The controls below cover who can see that material, which credentials can read source systems, how tag changes are recorded, how long samples persist, and which database and search services must be protected alongside the scanner. Confirm each item in your deployment before the first production scan.
Access to sampled values
Sample rows and classification results can expose personal data to anyone who can open a table profile or run a search that returns it, so visibility is the first control to set. Confirm which roles can view sampled values, whether that visibility can be limited per table or domain, and whether a reviewer role can see tags without seeing raw samples. Ask the vendor which roles are granted by default in a fresh install, then test them with a non-admin account before scanning production sources.
Connector credentials for scanning
Each database connector used for sampling needs credentials that can read the source tables. Those credentials often carry broader read rights than the catalog needs, so a scanning account with access to every schema becomes a route to personal data. Confirm that the connector account is read-only, limited to the schemas in scope, stored in your secrets manager and rotated on your schedule. Check how the connection secret is handled in the metadata store and in logs.
Audit of tag changes
Automatic tags come from rules and confidence thresholds, and people can add or remove them later. Without a record of who or what applied or removed a PII tag, a compliance review cannot show when a column was classified or reclassified. Confirm which tag changes are logged, whether each entry records the actor, the time and the previous value, and how long the log is kept outside the metadata store. Test by changing a tag and reading the resulting audit trail.
Retention of samples and results
Sampled values and scan results are stored in the metadata store and indexed in the search service, so removing a table needs an explicit deletion path for each copy. Confirm where sample data is persisted, whether it is written to the metadata store or held only during the scan, how deleted assets are purged from the search index, and whether backups of both services keep copies beyond that purge. Record the answers in your retention schedule before the first scan runs.
Database and search dependencies
The scanner depends on the OpenMetadata server, its database and its search service. The bare metal documentation lists Java 21, MySQL 8.0.42 or later or PostgreSQL 15 or later, and Elasticsearch 9.x or OpenSearch 3.x as prerequisites, with minimum sizing of 2 vCPUs, 2 GB RAM and 30 GB storage for each service. Both services hold classification data, so apply the same encryption, access control, patching and backup standards you use for other systems of record.
SSO and authentication method
OpenMetadata documents SSO with Auth0, Azure, Google, Okta, Amazon Cognito, OneLogin, Keycloak and custom OIDC providers. It does not support using multiple authentication mechanisms at once, so SSO cannot be combined with basic authentication on the same deployment. Plan the identity cutover before go-live, including how administrator access works if the identity provider is unavailable. Confirm with the vendor how the initial admin path works under SSO and who holds it.
What PII auto-classification costs and what it needs from your team
What drives the effort of PII auto-classification?
The main drivers are the number of sources, the sensitivity of the data in them, the review workload, the mapping decisions and your upgrade cadence. Number of sources: each database, warehouse or file store needs its own connection, scan scope and test run. Data sensitivity: regulated datasets need stricter sampling rules, tighter access and more careful review. Review workload: the volume of low-confidence matches decides how many columns a person must check. Mapping decisions: choosing how PII tags map to confidentiality tags takes agreement across privacy, security and data teams. Upgrade cadence: each OpenMetadata release can change defaults and ingestion behavior, so the rules need retesting. Ask your provider to price each driver separately in the written scope.
Can our own team run a PII auto-classification pilot alone?
Yes, a team can run a pilot alone if it already operates the platform and has someone comfortable with its ingestion framework, classification settings and database access. The pilot works best with one or two named sources, a agreed list of PII categories and a reviewer who can judge the results. Teams without that experience usually struggle with sampling choices, confidence thresholds and the tag mapping, which are the parts that affect privacy outcomes. Decide early who owns the configuration after the pilot ends, since that person will maintain the rules through upgrades.
What do data owners and privacy staff need to contribute?
Data owners confirm which tables and columns belong to them, approve access for the scan and review the tags applied to their data. Privacy staff define the PII categories that matter for your jurisdictions, set the rules for what counts as personal data and decide how automatic tags feed their review process. Security staff approve the database credentials and sampling scope. Expect these people to spend time in review sessions rather than in configuration work, and ask the provider to list each contribution with its owner in the written scope.
How long does a PII auto-classification pilot take?
No general duration applies, because the timeline depends on how many sources are in scope, how quickly access approvals arrive and how many review rounds the privacy team needs. Ask for a written scope that lists each phase, the sources included, the access steps, the review sessions and the acceptance criteria for the pilot. Also ask which tasks depend on your teams, such as credential issuance or privacy sign-off, because those dependencies often decide the schedule more than the technical work does.
Do automatic PII tags replace a privacy review?
No, automatic tags feed the privacy review and do not complete it. The classifier proposes tags based on column names and sampled values, and each tag carries a confidence level that a person must judge. Your privacy team still decides what is personal data, what the lawful basis is for processing and which controls apply. Treat the tags as a worklist that reduces manual searching, and record the reviewer's decision alongside each tag so the evidence shows a human made the call.
What does the sampling setting change for privacy?
Sampling reads actual values from your tables, so the sampling setting is a privacy decision as well as a performance setting. OpenMetadata 2.0 made Dynamic Sampling the profiler default, so confirm whether that default suits each source and whether sampled values are stored, displayed or retained. Restrict sampling on the most sensitive tables, document the sample scope and confirm who can see sample values in the interface. Ask your provider to test these settings on a non-production copy before any production scan.
What infrastructure does OpenMetadata need before classification runs?
Bare metal installs need Java 21, MySQL 8.0.42 or later or PostgreSQL 15 or later, and Elasticsearch 9.x or OpenSearch 3.x. The documented minimum server is 2 vCPUs, 4 GB RAM and 20 GB storage, with the database and search services each needing at least 2 vCPUs, 2 GB RAM and 30 GB storage. These are minimums from the project's deployment documentation, not production sizing. Production sizing depends on the number of sources and the sampling volume, so ask for it in the written scope, and confirm the versions against the release notes before you install.
What to confirm in your OpenMetadata version
OpenMetadata's PII detection is only as dependable as the release, sources and data behind it. The six checks below cover what your version ships, where it can scan, how results move to other metadata, how accurate it is on your own data, and how to move from 1.x to 2.0. Confirm each one against vendor documentation and a test source before you commit to a design.
Rules and recognizers in your release
Automatic PII detection depends on the column-name rules and content recognizers that ship in your exact OpenMetadata version. Recognizer coverage changes between releases, so a rule you rely on may be absent or renamed after an upgrade. Export the list of built-in recognizers from your version, compare it with the personal data categories your policy requires, and record gaps as custom recognizer work. Confirm against the release notes and by running a labeled test table.
Supported sources for content scanning
Sample-data scanning only works on sources that the connector and profiler support in your release. Support can differ by database, warehouse, file store or streaming source, and some sources may allow only metadata-based classification. List every source that holds personal data, then confirm for each whether content scanning, metadata-only classification or neither applies. Check the connector documentation for your version and run a pilot ingestion against a non-production copy before you plan production coverage.
Mapping and tag propagation behavior
Detected PII tags must map to confidentiality tags, and that mapping decides who sees what downstream. Confirm how the mapping is configured, whether tags propagate from a column to lineage-connected assets or dashboards, and whether propagation overwrites tags that a steward set by hand. Test a table with a known classification through a lineage edge and inspect the result. Record which direction tags move and which team owns changes to the mapping.
Accuracy on your own data
Vendor documentation describes how the detectors work, not how often they are correct on your tables. Precision and recall depend on your naming conventions, data formats and how much free text sits in each column. Build a labeled sample from your own schemas, include columns that are known to be negative, run the classifier, and measure false positives and misses for each tag. Do not accept any accuracy claim without this test, and set the confidence threshold from its results.
Non-English and domain-specific identifiers
Built-in recognizers are written around common formats, so national identifiers, local phone and address formats, and internal account numbers may go undetected or trigger false matches. Identify the identifier types used in each jurisdiction and internal system, then check whether a custom recognizer or regular expression exists for each one. Test with examples in every language and format in use, including names with diacritics and non-Latin scripts, and confirm the release handles them as expected.
Upgrade path from 1.x to 2.0
OpenMetadata 2.0.0 was released on August 24, 2026, and it changes several areas that affect classification setups. The release notes list breaking changes, including embedding credentials moved into an llmConfiguration block, a new Databricks authentication format, custom ingestion images rebuilt for Python 3.12, and Great Expectations migrated to 1.3 before upgrading. Dynamic Sampling is now the profiler default, so reconfirm your sampling settings. Plan a staging upgrade and retest classifications afterward.
How DeployOpen works on this
DeployOpen plans, implements, customizes, documents and supports self-hosted OpenMetadata inside your own infrastructure, so classification rules, sampling settings and tag mappings run where your data already lives. Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.
How we scope
- Inventory the connected sources, schemas and columns in scope for PII classification and who owns each one.
- Agree which column-name rules and sample-data scans run, and which data sets are excluded from sampling.
- Define the confidence thresholds, review workflow and mapping from PII tags to your confidentiality tags, in writing.
How we build
- Configure the auto-classification pipelines on your OpenMetadata instance and test them against representative tables.
- Tune confidence settings using labeled sample columns and record false positives and false negatives for review.
- Document the sampling configuration and its privacy trade-offs so data owners can approve it before production runs.
How we hand over
- Deliver the written rule set, tag mappings, sampling settings and test results as versioned, reviewable documentation.
- Walk through the review queue so your data stewards know how to accept, reject and correct classifications.
- Provide a runbook covering reclassification after schema changes, new connectors and tag catalog updates.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer after handover.
- Plan upgrades against the OpenMetadata release notes, including changes to profiler defaults that affect sampling.
- Confirm with your team which support scope, response expectations and review cadence fit your environment before signing.

