Buyer’s Guide

Best PII Detection and Data Privacy Tools

Written by Govind Kumar Lohar. Reviewed for technical accuracy by Deepak Gupta and Bhaskar Suthar on · Review panel

  • privacy
  • pii
  • gdpr
  • security

Independent buyer’s guide. No vendor paid to be included, ranked or described a particular way. Written for engineers, architects and the people who sign off on their tooling budget. Editorial policy.

Every engineering team discovers the same thing when it first tries to answer where personal data lives: the answer is everywhere, and nobody has a map.

It starts reasonably. There is a users table, and it has names and email addresses, and that seems like the whole of it. Then somebody remembers the support ticket system, which is full of customers pasting their own details into free text. Then the analytics warehouse, which received an event payload containing a full shipping address because an engineer sent the whole order object. Then the log aggregator, where a request body was logged during a debugging session in 2023 and the retention on that index is two years. Then the object storage bucket of uploaded documents. Then the data science notebook someone ran against a production snapshot. Then the backups of all of the above.

This is the actual shape of the problem, and it explains why the tooling in this category splits into two very different kinds of product that get sold as one. Detection tools find personal data across your systems. Privacy operations platforms manage the legal workflow: requests, consent, records of processing, and the promise to a regulator that you did something. A team that buys the second while needing the first ends up with a beautiful request-handling portal and no ability to fulfil a request, because fulfilment requires knowing where the data is.

The deletion request is where the two meet and where most programmes fail. Accepting the request is easy. Deleting the row is easy. Deleting the copy in the warehouse, the copy in the search index, the copy in the analytics platform, the copy in the support tool, and the copies in seven years of backups, then attesting that you did, is the hard part. That is the part worth evaluating tools on.

Key takeaways

  • Detection in structured data is a solvable problem. Detection in free text and documents is probabilistic, and the accuracy varies enough by data type that it must be measured on your own corpus rather than taken from a vendor page.
  • Redacting in the pipeline before data lands is cheaper and more reliable than discovering it afterwards, because discovery is a permanent recurring cost while redaction is a one-time integration.
  • Deletion is a distributed systems problem. The request workflow is trivial; propagating deletion across every downstream copy and proving it happened is not.
  • GDPR is a regulation, not a product. No tool makes you compliant, and any that claims to is selling you a workflow and a report.

GDPR: the regulation underneath, not a product

GDPR is European law governing how personal data about individuals in the EU is processed. It applies based on whose data you hold rather than where your company is, which is why teams with no European office still end up in scope. It is enforced by supervisory authorities, and there is no certification, no audit body, and nobody who issues you a pass.

The parts that produce engineering work, rather than policy documents:

A lawful basis for every processing activity. Consent is one of six, and frequently the worst choice, because consent can be withdrawn and then you must stop. Legitimate interest, contractual necessity and legal obligation cover most product functionality more durably.

Data subject rights. Access, rectification, erasure, portability, restriction and objection. Each one is a workflow with a deadline. Access and erasure are the two that dominate the engineering cost.

Purpose limitation and data minimisation. You collect for a stated purpose and do not repurpose freely, and you keep what you need rather than everything you can get. This is a schema and pipeline constraint, not a policy statement, and it is the principle most routinely violated by analytics instrumentation.

Records of processing. A maintained inventory of what you process, why, on what basis, who you share it with, and how long you keep it. Boring, mandatory, and the artefact privacy platforms are genuinely good at holding.

Breach notification within a defined window. Which means detection has to work, which loops back into your logging and monitoring.

Processor obligations flowing down. Your subprocessors must offer equivalent protections, which means contracts and diligence on every vendor that touches personal data.

Similar structures exist elsewhere with different details, notably in California and a growing set of US states, and in sector rules like HIPAA. The engineering primitives are the same: know where the data is, limit what you collect, honour requests, prove it.

What it gives you

  • A forcing function for a data inventory, which is something engineering teams want and never get funded on its own merits
  • Data minimisation as an enforceable principle, which is the strongest argument you will ever have against the instinct to log everything and keep it forever
  • Clear individual rights, so the ambiguous question of what a user may ask for has a defined answer with a deadline
  • Pressure on vendor diligence, which improves your supply chain hygiene as a side effect
  • A reason to build deletion propagation properly rather than as a soft delete flag nobody trusts

What it does not do

  • Tell you how. There is no specified architecture, no required tool, no approved technique. The regulation states outcomes and leaves implementation entirely to you
  • Certify anything. Nobody grants you a GDPR certificate, and a vendor claiming to make you GDPR compliant is describing a workflow product
  • Define what counts as deletion in a distributed system. Whether anonymisation is sufficient, whether backups must be purged immediately, and what to do about immutable logs are judgment calls your counsel makes, not settled technical answers
  • Cover security controls in detail. It requires appropriate measures without specifying them, which is why teams map to frameworks like SOC 2 or ISO 27001 for the security half
  • Apply uniformly. Member state interpretations differ, and other jurisdictions have their own regimes with overlapping but not identical obligations
  • Resolve the tension with audit logging. An append-only security log and an erasure right genuinely conflict, and the resolution is data minimisation in the log plus a documented legal basis for retaining it

In a comparison table, GDPR belongs on its own row marked as a regulation, because it is the obligation the products point at rather than one of the products.

Detection across structured and unstructured data

Vendors publish a single accuracy claim. There is no such thing, because the problem is three different problems with three different difficulty levels.

Structured data with known schemas. A database column called email_address containing values matching an email pattern. This is close to solved. Pattern matching plus column name heuristics plus sampling gets you most of the way, and the residual errors are mostly interesting corners: a notes column in a customers table that people use as free text, an external_ref column that turns out to hold national identifiers for one legacy integration, a JSON blob column that could contain anything.

The real difficulty in structured data is not detection, it is coverage. Finding the personal data in a database you know about is easy. Knowing about every database is not. Shadow data stores, a forgotten staging replica, a data science team’s own warehouse, an analytics tool nobody in engineering provisioned.

Semi-structured data. JSON payloads in event streams, log lines, API request bodies. Keys give strong hints, values give patterns, and the failure mode is nesting and variation: an event whose payload shape depends on a type field, where one of forty types carries an address. Sampling misses rare types by construction, which is exactly the type that will carry the sensitive field.

Unstructured text and documents. Support tickets, chat transcripts, uploaded PDFs, scanned images, call recordings. This is genuinely hard, it is where detection accuracy varies most between tools, and it is where the marketing claims are least meaningful.

Why it is hard, specifically. Names are the worst case: there is no pattern, name-shaped strings appear constantly in text that is not a name, and non-Western names defeat models trained predominantly on Western ones in ways that produce a quiet fairness problem as well as an accuracy one. Addresses vary enormously by country and format. National identifiers have different structures per jurisdiction and some have no checksum to validate against. Context decides everything: a sixteen digit number is a card number, an order reference or a session token depending on what surrounds it. And a document may be an image, so detection depends on optical character recognition working first, which introduces its own error rate before the detector even runs.

The two errors have completely different costs and the tradeoff is not symmetric. A false negative is unredacted personal data sitting in a system that should not have it, which is the failure that becomes an incident. A false positive is a redacted transaction identifier that breaks a support workflow, which is annoying and visible and generates complaints immediately. Teams tune toward fewer false positives because those are the ones people shout about, and in doing so quietly accept more of the failure that actually matters.

Needs first-hand data: Build a labelled sample from your own data: a few hundred records each from your free-text fields, your event payloads and your uploaded documents, hand-labelled for the specific entity types you care about. Run every candidate tool against it and record precision and recall per entity type, separately for each data source. Vendor accuracy figures are measured on their corpus, not yours, and the gap between the two is the entire basis for choosing.

Redaction in the pipeline versus discovery afterwards

There are two architectural positions and the difference between them decides your recurring cost for years.

Discovery after the fact. Scan data at rest, classify it, produce an inventory, generate findings, remediate. The tool sits beside your systems and reads them. This is what most of the enterprise platforms in this category do.

It is the right answer for the data you already have, because that data is already everywhere and something has to find it. It is a permanent recurring cost, because new data arrives continuously and every scan is a snapshot that starts going stale immediately. And it finds problems after they exist, which for a breach-shaped problem means after the exposure window opened.

Redaction in the pipeline. Detection runs inline, before data lands. The log line is scrubbed before it ships. The event payload is filtered before it reaches the warehouse. The support ticket is redacted on ingestion. The prompt is cleaned before it goes to a model provider.

This is strictly better when you can do it, for three reasons. The data never exists in the wrong place, so there is nothing to discover and nothing to delete later. The cost is a one-time integration rather than a perpetual scan. And it composes with everything downstream, because a warehouse that never received an address does not need an address deletion path.

The catch is that it requires a choke point. If every service logs independently to its own destination, there is no single place to enforce redaction and you are back to discovery. Building or consolidating onto a pipeline is the prerequisite, which is why this category connects directly to log management architecture: a team that already ships everything through one collector can add redaction as a filter, and a team that has not cannot.

Two places where inline redaction is now close to mandatory. Logging, because logs are the single most common accidental repository of personal data and are retained longer than anyone intends. And anything leaving for a third party model provider, where a prompt containing customer data becomes a processing activity with a subprocessor you may not have disclosed. The guardrail layer for that is covered in LLM guardrails tools.

The pragmatic sequence for most teams. Redact inline at the two or three highest-volume choke points you actually control, because that stops the bleeding. Run discovery over the systems you already have, because the historical data will not redact itself. Do not attempt continuous discovery across every system simultaneously as a first project, because it produces an inventory nobody can act on and a finding backlog that becomes wallpaper.

Deletion requests are the hard part

Here is the part that decides whether your privacy programme is real.

A deletion request arrives. Verifying the requester is a real problem but a bounded one. Deleting the primary record is a query. Then the actual work starts, and the actual work is a distributed systems problem with no transaction around it.

Where the copies are. Your primary database, plus every read replica. The data warehouse, where an ETL job copied the row and probably a historical version of it. The search index. The cache, which may hold it for a while longer. The analytics platform, which has its own storage and its own deletion API with its own latency. The support tool, where the customer typed their details into a ticket body. The email service provider. The billing system, which you may be legally required not to delete from. The object storage bucket of uploaded files. Your logs, with whatever retention they have. Your backups, going back however far. And every subprocessor, each of which needs its own request through its own mechanism.

Why it is not one operation. No transaction spans those systems. Several of them are third parties with asynchronous deletion APIs and their own timelines. Some are append-only by design and deletion is architecturally impossible without rewriting history. Some hold data you must retain: financial records under tax law, security logs under a legitimate interest, records under an active legal hold.

What actually works. A deletion orchestration layer, which is a durable workflow, not a script. One record per system per request, each with a state and a retry, driven by a queue so that a system being unavailable delays that leg rather than failing the request. Conceptually a saga, and the reason it must be durable is that the whole thing spans days and you have to be able to answer what happened.

Backups are the honest exception. Purging an individual from backups is generally impractical, since backups are restore points rather than queryable stores. The accepted approach is documenting that backups are retained for a defined period, are not used for ongoing processing, and that a restored backup is reconciled against deletion records so that deleted subjects are removed again after restore. That last clause is the one teams forget to implement, and it is the one that makes the position defensible rather than convenient.

The anonymisation route. Rather than deleting a row with foreign keys pointing at it, replace the identifying fields with irreversible values and keep the record. This preserves aggregate analytics and referential integrity. It only counts if the result genuinely cannot be re-identified, and re-identification through combinations of remaining fields is easier than people assume, especially in small datasets where a timestamp plus a postcode plus an age is effectively a name.

What you must be able to prove. Which systems were in scope, what happened in each, when, and what remains with a documented reason. That evidence trail is itself a compliance artefact, which means it belongs in an append-only record, which means audit logging is a prerequisite for privacy operations rather than a parallel project.

Needs first-hand data: Run an end-to-end deletion request against a real test account and record it per system: how long each leg took, which required manual intervention, which had no API at all, and where the data was still present afterwards. Most teams have never run this test on production systems and discover on the first real request that a downstream system has no deletion mechanism.

Nightfall

Nightfall homepage

Nightfall is a detection service built around API-first classification, with connectors into common SaaS systems and a strong emphasis on catching sensitive data in unstructured places: chat messages, tickets, documents and code. The architecture suits teams who want detection as a callable service in their own pipeline rather than a platform to adopt.

Pros

  • Detection available as an API you call from your own code, which is exactly what inline redaction needs and what platform-shaped products make awkward
  • Focused on unstructured content where the hard detection problems live, rather than treating free text as an afterthought to database scanning
  • SaaS connectors cover the systems where personal data accumulates without anyone deciding it should
  • Lighter to adopt than the enterprise governance platforms, so a small team can get value without a programme around it

Cons

  • Detection service rather than a privacy operations platform, so records of processing, consent and request workflows are not in scope
  • Sending content to a third party for classification is itself a processing activity, which needs disclosing and may be rejected by regulated customers
  • Priced on volume, which makes inline redaction of a high-throughput stream a meaningful recurring cost
  • Accuracy on your specific entity types and languages must be measured rather than assumed, particularly for non-Western names

Best for: Engineering teams who want detection callable from their own pipeline for inline redaction and SaaS monitoring, without adopting a governance platform.

Pricing: Metered on the volume of content scanned, with per-connector and API-based plans.

BigID

BigID homepage

BigID is a data discovery and intelligence platform aimed at large, sprawling estates. Its distinguishing capability is correlation: connecting records about the same individual across many disconnected systems, which is the capability that actually makes a subject access or deletion request answerable at enterprise scale.

Pros

  • Identity correlation across systems is the genuinely hard capability here, and it is what turns a scattered inventory into a per-individual answer
  • Very broad connector coverage across databases, warehouses, file stores, SaaS and on-premises systems
  • Discovery goes beyond pattern matching into relationship and lineage, which finds data that a regex-based scan misses entirely
  • The inventory it produces feeds records of processing and access requests from the same source rather than from a separately maintained document

Cons

  • Enterprise platform with an enterprise implementation cost, which is disproportionate for a company with a dozen systems
  • Deployment and tuning is a project with a timeline, not a tool you connect in an afternoon
  • Discovery-oriented, so inline redaction at a pipeline choke point is not its shape
  • Findings volume on a first scan can be overwhelming, and without an owner the inventory ages into a document nobody trusts

Best for: Large organisations with sprawling, partly unknown data estates where the primary problem is not knowing what exists or how records relate.

Pricing: Enterprise annual licensing, typically scaled by data sources and volume under management.

Privacera

Privacera comes at privacy from the access control direction rather than the discovery direction. It centralises policy across data platforms, so that masking, row filtering and column-level permissions are defined once and enforced consistently in the warehouse and lake engines you actually query.

Pros

  • Policy defined once and enforced across multiple query engines, which is the only way masking stays consistent when three teams use three different tools against the same data
  • Access control and masking mean sensitive fields are protected in place rather than discovered after misuse
  • Fits naturally into a modern lakehouse architecture where the warehouse is the centre of gravity for personal data
  • Strong audit of who accessed what, which is the evidence privacy programmes need and rarely have for the analytics estate

Cons

  • Focused on the data platform, so personal data in application databases, SaaS tools and documents sits outside its reach
  • Requires a reasonably centralised analytics architecture to be worth it, and delivers little in a fragmented estate
  • Not a privacy operations platform, so subject requests, consent and processing records are elsewhere
  • Operationally significant to deploy and to keep aligned with a changing set of engines

Best for: Organisations whose personal data risk is concentrated in a data lake or warehouse accessed by multiple engines and many analysts.

Pricing: Enterprise licensing scaled by the data platforms and volume under policy management.

Microsoft Purview

Microsoft Purview is the data governance and protection layer for the Microsoft estate, covering classification, sensitivity labelling, data loss prevention and governance across Microsoft 365, Azure and connected sources. If your organisation runs on Microsoft, its reach into documents, mail and collaboration tools is unmatched by anything else on this page.

Pros

  • Deep coverage of Microsoft 365 content, which is where an enormous share of unstructured personal data actually lives in most companies
  • Sensitivity labels travel with documents and are enforced by the applications themselves, which is protection at the point of use rather than after discovery
  • Included in the licensing many organisations already hold, making it the lowest-friction starting point by a wide margin
  • Data loss prevention, classification and governance under one administrative surface rather than three products

Cons

  • Strongest inside the Microsoft ecosystem and noticeably weaker outside it, so a mixed estate needs a second tool anyway
  • Licensing is complicated, and which capabilities you have depends on tiers in a way that is genuinely hard to determine before deployment
  • Administrative complexity is high and the configuration surface rewards a dedicated owner
  • Application database and custom pipeline coverage is limited, so engineering-side personal data is largely out of scope

Best for: Organisations already standardised on Microsoft 365 and Azure whose unstructured personal data lives in documents, mail and collaboration tools.

Pricing: Licensed through Microsoft 365 and Azure tiers, with advanced capabilities gated to higher plans and some features metered on usage.

Presidio

Presidio is an open-source PII detection and anonymisation library, originally from Microsoft. It combines named entity recognition, pattern matching and checksum validation, exposes recognisers you can extend, and runs entirely inside your own infrastructure. For inline redaction it is the default starting point and deserves to be.

Pros

  • Runs entirely in your infrastructure, so content never leaves for classification, which removes the subprocessor problem that API-based detection creates
  • Custom recognisers are straightforward to add, which matters because your highest-value entity types are usually specific to your domain rather than generic
  • Anonymisation operators are included, covering redaction, masking, hashing and replacement rather than only flagging
  • No per-volume cost, which makes inline redaction of high-throughput streams economically viable where a metered API is not

Cons

  • A library, not a product, so orchestration, deployment, monitoring, tuning and the user interface are all yours to build and operate
  • Out-of-the-box accuracy on names and addresses in non-English languages needs real evaluation and usually real tuning before it is trustworthy
  • No discovery capability across your systems, since it classifies content you hand it rather than going looking
  • Model inference has a compute cost and a latency cost that must be designed for if it sits on a hot path

Best for: Engineering teams building inline redaction into their own pipelines who need detection to run in their own infrastructure with no per-record fee.

Pricing: No vendor and no bill. It is open source and free to use. The cost is the compute to run inference and the engineering time to integrate, tune and maintain it.

Skyflow

Skyflow homepage

Skyflow takes the most architecturally opinionated position in this comparison: personal data does not live in your database at all. It lives in a dedicated vault, and your systems hold tokens. Detection becomes largely unnecessary because sensitive data was never distributed in the first place.

Pros

  • Solves the problem by construction rather than by search, since data that only ever existed in one place does not need discovering across seven systems
  • Deletion becomes a single operation in the vault rather than a distributed workflow, which removes the hardest part of this entire article
  • Fine-grained access policies and audit around the vault give you per-field control that is difficult to achieve in a general database
  • Data residency becomes a vault configuration rather than an architectural rewrite, which is a genuinely strong position for multi-region products

Cons

  • Requires designing or rearchitecting around tokenisation, which is a serious commitment and much harder to retrofit onto a mature product than to adopt early
  • The vault is in the critical path for anything needing real values, which introduces a latency and availability dependency on customer-facing operations
  • Analytics gets harder, because tokenised fields cannot be joined or aggregated the way plaintext can without going back through the vault
  • Vendor dependency on the most sensitive data you hold, which raises the diligence bar considerably

Best for: Teams designing a new system, or willing to rearchitect, who want personal data centralised by construction rather than found by scanning.

Pricing: Metered on the volume of records stored in the vault and on API operations against it.

Transcend

Transcend homepage

Transcend is a privacy operations platform focused on the workflow that most tools treat as an afterthought: actually fulfilling data subject requests across every system, including third parties, with orchestration and evidence rather than a ticket and hope.

Pros

  • Request fulfilment orchestration across internal systems and third-party vendors is the specific hard problem, and it is the product rather than a feature
  • Integrations handle the per-vendor deletion mechanisms, which is repetitive work that has no engineering interest and must still be maintained
  • Consent management and preference handling live alongside fulfilment, so a withdrawal actually propagates instead of being recorded
  • Produces the evidence trail regulators and auditors ask for as a by-product of doing the work

Cons

  • Fulfilment depends on knowing where the data is, so it complements discovery rather than replacing it and a team with no inventory will still stall
  • Integration coverage for your specific internal systems needs checking, because custom services always need custom work
  • Priced for companies with a real privacy programme, which is disproportionate for a team handling occasional requests
  • Adds another platform in the path of an obligation with a legal deadline, which raises the stakes on its availability

Best for: Companies with meaningful consumer request volume across many internal and third-party systems who need fulfilment orchestrated and evidenced.

Pricing: Annual subscription scaled by request volume and the number of integrated systems.

OneTrust

OneTrust is the incumbent privacy management platform and the one most likely to already be in use if your company has a legal or compliance function. Its scope is programme management: assessments, records of processing, consent, cookie compliance, vendor risk and request intake, across many jurisdictions.

Pros

  • Broadest coverage of privacy programme management, including the assessments and records of processing that regulators actually ask to see
  • Multi-jurisdiction support that keeps pace with new regimes, which is real ongoing work you would otherwise track yourself
  • Consent and cookie management at scale, including the parts that are genuinely fiddly across regions
  • Familiar to legal and compliance teams, which reduces internal friction when privacy is not owned by engineering

Cons

  • Programme management rather than technical discovery, so it tells you what you declared rather than what is actually in your systems
  • Large, complex product with substantial implementation effort and a configuration surface that rewards a dedicated administrator
  • Priced for enterprises with a privacy function, and hard to justify without one
  • The gap between the declared inventory and reality is where privacy programmes fail, and this shape of product does not close it

Best for: Organisations with a legal or privacy function that needs programme management, assessments and multi-jurisdiction records in one place.

Pricing: Enterprise annual licensing by module, scaled by employee count and the capabilities in scope.

How to choose

Decide which of the three problems you actually have, because buying for the wrong one is the dominant failure in this category.

You do not know where personal data is. Discovery. BigID at enterprise scale, Microsoft Purview if your estate is Microsoft-shaped, Privacera if the risk is concentrated in the data platform. Expect a project, not an installation.

You know where it is and want it to stop spreading. Inline redaction. Presidio in your own pipeline if you have the engineering capacity and want no per-record cost, Nightfall if you want it as a service and the volume economics work. Do this at your logging choke point first, because logs are where personal data accumulates most and is retained longest by accident.

You have requests to fulfil and a deadline attached. Transcend for orchestration across systems, OneTrust if the requirement is programme management and your legal team is the owner. Neither works without knowing where the data is, so if you have no inventory you have the first problem, not this one.

You are early enough to design around it. Skyflow, or the same pattern built yourself. Centralising personal data behind one boundary is the only approach here that makes deletion a single operation, and the window to choose it closes as the product matures.

For most engineering-led teams, the honest sequence is: redact inline at your two biggest choke points, build the deletion orchestration workflow yourself because it is the part nobody can build for you without your system map, and only then evaluate a discovery platform for the historical estate.

ToolPrimary jobStructuredUnstructuredDeletion orchestrationPicks itself when
NightfallDetection as an APIPartialStrong focusNoYou want detection callable from your pipeline
BigIDDiscovery and correlationStrongStrongFeeds itThe estate is large and partly unknown
PrivaceraPolicy and masking in the data platformStrongLimitedNoRisk is concentrated in the lake or warehouse
Microsoft PurviewGovernance across the Microsoft estatePartialStrong in Microsoft 365PartialYou already run on Microsoft
PresidioDetection and anonymisation libraryYou supply the dataStrong with tuningNoInline redaction in your own infrastructure
SkyflowVault so data never spreadsBy constructionNot applicableSingle operationYou can design or rearchitect around it
TranscendRequest fulfilment across systemsNeeds an inventoryNeeds an inventoryIts entire purposeRequest volume is real and systems are many
OneTrustPrivacy programme managementDeclared, not discoveredDeclared, not discoveredIntake and workflowLegal owns privacy and needs the records
GDPR (regulation, not a product)The obligationDefines the dutyDefines the dutyDefines the deadlineNever a choice, it is the law you are under

Frequently asked questions

Do I need a PII detection tool if I know my schema?

If your personal data genuinely only lives in a handful of typed columns you designed, then no tool will tell you anything you do not know, and your effort belongs in deletion propagation instead. That situation is rarer than it feels. The question to ask is not about your schema, it is about your free-text fields, your event payloads, your logs and your uploaded files. Those are where detection earns its cost, and almost every product has all four.

Can I redact personal data from logs after the fact?

Partially, and it is the expensive way to do it. Reprocessing existing indices is possible in some log platforms and impossible in others, backups of those indices are effectively permanent, and any copy already exported downstream is beyond your reach. Inline redaction at the collector costs a one-time integration and stops the problem at the source. If you are going to do one thing from this article, filter your log pipeline. The architecture for that is in best log management tools.

How do I handle deletion when I have immutable audit logs?

You do not delete them, and you make sure they do not need deleting. The defensible position combines two things. First, the audit log is retained under a legal obligation and a legitimate interest in security, which is a documented lawful basis rather than an oversight. Second, the personal data inside it is minimised at write time to identifiers and role names rather than rich personal detail, so what remains is proportionate to the purpose. That design decision belongs in the schema, which is covered in best audit logging tools.

Is anonymisation enough, or do I have to delete?

Genuine anonymisation takes data outside the regulation entirely, because it is no longer personal data. The word doing the work is genuine. If the result can be re-identified, by you or by anyone, through the remaining fields or by combining with another dataset, it is pseudonymisation and remains in scope. Small datasets re-identify far more easily than people assume, because a handful of quasi-identifiers is often unique. Treat any claim that hashing an email address anonymises a record with suspicion, since the same input produces the same hash and that is a stable identifier.

Where does PII detection fit in a wider security programme?

It sits alongside the rest of the data protection controls rather than replacing any of them. Detection tells you what you hold and where, access control limits who can reach it, encryption protects it at rest and in transit, and monitoring tells you when something unusual happened. A privacy tool with weak access control underneath it produces an excellent inventory of data that anyone can read. The full control set is in best application security tools.