Submitted:
11 November 2026
Posted:
12 November 2026
You are already at the latest version
Abstract
Many teams can say how a new feature creates data. Fewer can say how that data will be deleted: where every copy lives, which service removes it, in what order, by when, at what load, and how anyone would check that it is gone. Answering those questions after release is expensive, because copies have already spread into indexes, caches, analytics stores, and backups. This article proposes a 12-item deletion-readiness checklist that a feature team and its platform team complete before release. It draws on a large messaging platform’s deletion system and on published studies of deletion failures. Each item names the failure it addresses and the red flags of a weak answer. A worked example shows good answers, and a release gate makes them a written, owned commitment.
Keywords:
data deletion
; right to erasure
; privacy engineering
; data lifecycle management
; information governance
; distributed systems
; software release management
; GDPR
Deletion is a feature that every other feature depends on and that almost no feature owns. A user deletes a message, an administrator removes a user, a tenant leaves the service, a retention policy expires a year of chat history. Each request must reach every place the data went: the primary store, the search index, the analytics warehouse, the change log, and the backup.
Studies show how this goes wrong. Researchers who examined 678 mobile apps with their own account systems found 17 that still held account data server-side after users deleted their accounts, and 437 with no way to delete an account.[1] Another study sent erasure requests to 90 online services and judged 27% of them non-compliant.[2] A recent preprint on vector databases used for retrieval-augmented generation reports that, in three implementations, deleting an embedding only flagged it, leaving it recoverable.[3] None of these failures needs an exotic bug; each is consistent with data created without a plan to delete it. Under the European Union’s General Data Protection Regulation (GDPR), a controller must erase personal data without undue delay when a ground for erasure applies, subject to exceptions such as legal obligations and legal claims (Art. 17(1), (3)).[4]
I work on data deletion at a large messaging platform, including retention policies, cleanup (removing the data of deleted users, conversations, and tenants), and keeping that work from overloading downstream services. A recurring lesson is that a deletion system can remove only what it can find, and it can find only the stores that feature teams have told it about. This article turns that experience into 12 questions (Table 1) to answer before release (broad deployment), when answers are cheapest.
Prior work examines how system designs conflict with the GDPR,[5] how one company drives deletion from developers’ annotations (DELF),[6] and which implementation pitfalls regulators’ erasure rulings reveal.[7] Data protection impact assessments and data protection by design (Arts. 35 and 25) [4] ask whether processing is justified and safeguarded. The checklist asks what those duties leave to engineers: can every copy the feature creates be found, removed on time without harming live traffic, and shown to be gone? Our mapping study [8] organizes deletion research by six concerns; the checklist covers all six as release questions.
1. Where Deletion Goes Wrong
Revocation hides data from users, typically with a deleted flag or a visibility rule; erasure makes every copy in scope unrecoverable, by deleting it or by destroying a key that encrypts only that data. Erasure is harder because a feature’s data rarely stays in one place (Figure 1). Primary copies live in the store of the service that owns them. Derived copies are computed from them: search index entries, cache entries, aggregates, embeddings, thumbnails. Secondary copies are kept for durability: replicas, change logs, backups.
Against that footprint, deletion fails in seven ways:
- Incomplete deletion—some copy is never reached.
- Over-deletion—data that should have been kept is removed: data under a legal hold or retention rule, shared with another user, or no longer eligible when the delete runs.
- Orphaned data—deletion removes the last reference to data not yet deleted, so no later process can find it.
- Late deletion—every copy is removed, but after the deadline.
- Collateral load—a burst of deletion work degrades the service for users who deleted nothing.
- Resurrection—deleted data comes back, for example from a stale replica or a backup restore.
- Unprovable deletion—deletion may be complete, but nobody can show it.
2. The Checklist
1. Inventory every copy. Start with the data the feature writes, then follow it. The inventory names each copy, its store, and how it is removed: by an explicit delete, by expiry after a known time-to-live (TTL), or by destroying an encryption key. A good answer is short and specific (see Table 2); “it’s in our database” is not. Red flags: only the primary store is listed; nobody can say where the analytics pipeline copies the data; “we don’t index it,” without checking the platform’s indexer.
2. Name the owner of every record. Deletion is scoped to an entity: a user, a conversation, a tenant. For each record, write down which entity it belongs to and whether it can belong to several. A message in a group conversation belongs to the conversation, not only to its author, so it can remain after the author’s account is deleted. A file shared into several conversations may have several owners. For shared data, decide per data type whether deleting one owner removes the item, removes only that owner’s part, or leaves it to the remaining owners, and check for remaining owners after each removal so that no ownerless item is left behind. On our platform, a member’s per-conversation state has two owners, the user and the conversation, and each owner’s cleanup deletes it. Red flags: “the author owns it” for data that other participants see; identifiers that refer to a user but are stored under a conversation, or the reverse.
3. Make the deleting service discoverable. The deletion system must find every service that holds data for an entity without a code change each time a feature adds a store. On our platform, user cleanup gets the list of a user’s stores from the service responsible for user-scoped data, cleans every store on it, and removes the list itself last, so a newly registered store is included automatically. Ask who would notice if this feature’s store were never registered. Red flags: the store was created outside the platform’s usual provisioning path; deletion is “handled by a script” that runs on demand.
4. Expose an idempotent deletion interface. Because deletion tasks get retried, repeated, and postponed, each service’s delete operation should take a scope, such as an entity identifier or a range, and be safe to call more than once. Two outcomes that look like failures are not errors: “not found” (already deleted) is success, and “no longer eligible” (item 5) is a recorded no-op; treating them as errors causes needless retries and false alerts. The opposite mistake is worse: a broken query that matches nothing also returns “not found” and hides data that was never deleted. The interface should state its batch size, how it paginates, and how it tells the caller to slow down. Red flags: deletion implemented only as a flag, which is revocation without a path to erasure; a delete call that returns success before anything is removed and gives no way to check later.
5. Recheck eligibility when deletion runs. Data may be under a legal hold, inside a retention period, subject to an exception in data-protection law,[4] or restored by the user before a delayed task runs. The usual pattern rechecks eligibility against current authoritative state and records a skip if it no longer holds. If data can be restored, or put under a hold, after deletion starts, recheck before each step. Our platform does not revive an entity whose cleanup has begun. It preserves data under hold in separate compliance copies, made when data is written and kept outside the stores that cleanup erases; those copies need their own retention and evidence. Red flags: the task carries a cached copy of the decision (“this user is deleted”) and never rereads it; holds are checked only when the request is accepted, or only by the user interface.
6. Decide the order. Across services, no transaction deletes a parent and all its children atomically. When the parent is the only path to its children, deleting it first orphans them. Delete bottom-up; because enumeration misses children added later, block new ones and recheck before the parent goes. If a parent must go first, for example a user account that the identity provider deletes, record the child’s identity durably when the child is written, and keep it until the child is deleted. On our platform, cleanup workflows delete a parent only after every descendant they enumerate, and if a child’s deletion fails, so does the parent’s; owning services reject ordinary writes under a deleted entity; and the conversation service will not delete a conversation while messages or members remain. Red flags: the only way to find the feature’s data is through a parent that is deleted first; “we’ll garbage-collect it later,” without saying how the collector will find it; children listed from a lagging index.
7. Write down the deadline. The completion deadline—the maximum time from a start event until every copy is gone—comes from law, contract, or internal policy; record it per entity type. Some copies expire instead of being deleted, such as a cache with a fixed TTL. Require an explicit bound for that expiry and budget it, together with any wait after the start event, against the same deadline. On our platform, the clock for a deleted message, conversation, channel, or group of channels starts when the product’s bounded undo window ends; for users, when the identity provider hard-deletes them; for tenants, at subscription end. A written deadline turns the GDPR’s “without undue delay” (Art. 17(1)) [4] into an engineering target. Red flags: “as soon as possible” instead of a number, or no start event; a TTL on a derived store that is longer than the deadline, or that can be paused or extended.
8. Budget the deletion load. Bulk deletion arrives in bursts, such as a large tenant leaving, a shortened retention period, or a backlog released when an outage ends, and a burst of internal delete calls can degrade the stores that serve live users. Rate limiting is often configured only at the gateway, which the deletion system bypasses when it calls internal services directly. The feature team should state how much deletion traffic its stores can absorb and how they signal overload, and the platform should enforce that budget on the caller’s side. On our platform, the deletion system bounds its own traffic with fleet-wide per-API, per-region, and per-conversation budgets, and every deferred task stays in durable storage. Throttling trades collateral load for late deletion, so alert on deadline slack (time to spare after the remaining work runs at the budgeted rate), not queue length. Red flags: “deletes are cheap” for a store that rewrites or compacts on delete; no throttling response; load tests that cover only user traffic.
9. Plan for resurrection. Deleted data returns through a stale replica merged back,[9] a cache refilled from an outdated source, a migration still copying the data, a reindex from an undeleted copy, a change-log replay, or a backup restore. For each path that applies, name what prevents it. Tombstones, markers that record a deleted item’s identifier, can travel with replicated or migrated data, as in the live migration protocol [10] deployed on our platform; they must outlast every copy they suppress, then expire. Replay and restore should reapply deletions newer than the data they bring back. On our platform, disaster-recovery replay, backup restore, and per-item recovery are designed to do so, and backups are retained under their own policy rather than the cleanup deadline. Because erasure is hard to apply to backups,[11] a platform should tell feature teams when backups expire or have their keys destroyed, whether within the deadline or on a separately stated schedule. Red flags: a cache refilled from a source that serves deleted data; a restore runbook that never mentions deletion.
10. Verify through a different path. A success response means the call ran, not that every copy is gone. Verification should list what remains through its own query, because reusing the deletion path would repeat its blind spots. Where two interfaces can enumerate the same data, comparing them can expose what one of them misses. A clean result shows only that the queried interfaces return nothing. A periodic sample, sized to the miss rate you need to detect, suits many features; for high-risk data, verify every deletion. Track completion times against the deadline, not only success rates. DELF reports that, of about 12 billion deletions that finished on one day, 99.99999% had completed within its 90-day target;[6] such a sample cannot show deletions that never finish. Red flags: “the delete call succeeded” is the only evidence; verification uses the same query that drove deletion.
11. Keep evidence that does not recreate the data. Evidence can include a reference to the request, any hold or exception, the eligibility decision, per-service acknowledgments, task completion, and verification results. The trap is evidence that contains the personal data it shows was removed: a log line with the message text, an audit record with the user’s name. Keep evidence minimal, access-controlled, and on its own retention schedule. Red flags: deletion logs that include content “for debugging”; evidence kept forever because nobody set its retention period.
12. Test deletion continuously. Deletion paths rot quietly: a schema change, a new derived copy, a renamed store. A synthetic canary periodically creates approved test data through the feature, deletes the owning entity, waits for cleanup, and verifies that nothing remains in any store. Red flags: deletion was tested once, manually, before release; test data is cleaned up by a separate script instead of by the deletion path.
3. A Worked Example
Consider a hypothetical feature: emoji reactions on chat messages. Table 2 gives the kind of short answers a feature team might write.
4. Using the Checklist
Make the checklist a release gate with a named owner, not a review meeting, so that a feature cannot be released without written answers kept next to the code. For each shared item in Table 1, name one person on each side. A one-page template like Table 2 is enough; a machine-readable deletion contract could later automate the gate. Start with the inventory, because items 2–12 depend on it. Rerun the checklist when the feature adds a store, a derived copy, or a sharing model, and when the platform changes its backup, replication, or migration behavior. For features already in production, begin with those whose data reaches the most copies. Accept “not yet” as an answer, and record it: “we do not verify completion yet” turns an unknown risk into a known backlog item with an owner.
5. Limits of the Checklist
The 12 items were derived from platform experience and the mapping study.[8] The checklist has not been used outside our team; this article reports no evaluation of it as a release gate. It does not decide legal questions, such as the operator’s role, whether an exception applies, how long a hold lasts, or whether a technical end state satisfies the law. Privacy and legal teams make those decisions; the checklist only makes sure the system can act on them (item 5). It covers stored artifacts such as embeddings and indexes, but not the influence of deleted data on trained models. It covers copies the operator controls (item 1 also lists device copies and exports), not storage-level residues or media sanitization. An operator acting as a processor receives this work through its contract (Art. 28(3)); sub-processors need contractual terms (Art. 28(4)), and the controller must notify other recipients (Art. 19).[4]
6. Conclusions
The checklist rests on one observation: deletion failures can start outside the delete code, in inventory gaps, ownership surprises, missing load budgets, and recovery paths that nobody connected to deletion. Our mapping study lists open research problems.[8] The lesson I draw is to treat deletion readiness like any other release criterion: answered in writing, owned, and revisited when the feature changes.
Acknowledgments
The checklist draws on work with my colleagues Jay Rajeevalochanam, Narasimhan Govindarajan, and Abhijit Rajan. I used Claude Opus 5.5 (Anthropic) to draft the text of all sections and the draw.io source of Figure 1, to edit and shorten the text, and to check it against the cited sources. I also used an AI assistant built on the Copilot SDK in VS Code to revise the text and prepare the submission materials. I reviewed and edited the output and take full responsibility for the content. The views expressed are my own and do not necessarily reflect those of Microsoft; descriptions of the platform state design intent and are not product or contractual commitments.
References
- Santhanam, P.; Dang, H.; Shan, Z.; Neamtiu, I. Scraping sticky leftovers: App user information left on servers after account deletion. Proc. IEEE Symp. Secur. Privacy (SP), May 2022; pp. 2145–2160. [Google Scholar] [CrossRef]
- Rupp, E.; Syrmoudis, E.; Grossklags, J. Leave no data behind: Empirical insights into data erasure from online services. Proc. Priv. Enhancing Technol. 2022, vol. 2022(no. 3), 437–455. [Google Scholar] [CrossRef]
- Chakraborttii, C.; García Alvarado, J.; Abdulofizova, S.; Dwivedi, S. Ghost vectors: Soft-deleted embeddings remain reconstructible in HNSW vector databases. arXiv 2026, arXiv:2606.18497. [Google Scholar]
- Regulation (EU) 2016/679 (General Data Protection Regulation). Off. J. Eur. Union 2016, L 119, 1–88.
- Shastri, S.; Wasserman, M.; Chidambaram, V. The seven sins of personal-data processing systems under GDPR. Proc. USENIX Workshop Hot Topics Cloud Comput. (HotCloud), Jul. 2019; Available online: https://www.usenix.org/conference/hotcloud19/presentation/shastri.
- Cohn-Gordon, K.; et al. DELF: Safeguarding deletion correctness in online social networks. Proc. 29th USENIX Secur. Symp., Aug. 2020; pp. 1057–1074. [Google Scholar]
- Sun, C.; Guggenberger, N.; Shastri, S. Faults and pitfalls in implementing the right to be forgotten. Commun. ACM 2026, vol. 69(no. 6), 50–59. [Google Scholar] [CrossRef]
- Roy, D.; Rajeevalochanam, J.; Rajan, A. Deleting data from distributed cloud services: A systematic mapping study and review. Preprints 2026. [Google Scholar] [CrossRef]
- DeCandia, G.; et al. Dynamo: Amazon’s highly available key-value store. Proc. ACM Symp. Operating Syst. Princ. (SOSP), Oct. 2007; pp. 205–220. [Google Scholar] [CrossRef]
- Roy, D.; Mulye, S.; Govindarajan, N.; Rajeevalochanam, J. Live cross-region data migration without perceived downtime: A four-phase protocol for multi-service cloud systems. Preprints 2026. [Google Scholar] [CrossRef]
- Politou, E.; Michota, A.; Alepis, E.; Pocs, M.; Patsakis, C. Backups and the right to be forgotten in the GDPR: An uneasy relationship. Comput. Law Secur. Rev. 2018, vol. 34(no. 6), 1247–1257. [Google Scholar] [CrossRef]
Figure 1.
The data footprint of one feature: primary copies in the owning service, derived copies computed from them, and secondary copies kept for durability. Each class is removed by a different mechanism, often owned by a different team, on a different clock, and verification has to cover all of them. Item numbers refer to Table 1.
Figure 1.
The data footprint of one feature: primary copies in the owning service, derived copies computed from them, and secondary copies kept for durability. Each class is removed by a different mechanism, often owned by a different team, on a different clock, and verification has to cover all of them. Item numbers refer to Table 1.

Table 1.
Deletion-readiness checklist. Each question is answered in writing before release. “Addresses” names the failure modes, defined in the text, that each item targets; “Answered by” names the feature team (F), the platform team (P), or both, and what each side owns.
Table 1.
Deletion-readiness checklist. Each question is answered in writing before release. “Addresses” names the failure modes, defined in the text, that each item targets; “Answered by” names the feature team (F), the platform team (P), or both, and what each side owns.
| # | Question | Addresses | Answered by |
|---|---|---|---|
| 1 | Inventory every copy. What data does the feature store, and where? List every primary, derived, and secondary copy, including logs, telemetry, compliance copies, copies on users’ devices, and exports. | Incomplete deletion | Both: F its copies; P replicas, logs, backups, indexers |
| 2 | Name the owner of every record. Which entity owns each record, and can a record have several owners? | Over-deletion, incomplete deletion | F, with the privacy team for shared data |
| 3 | Make the deleting service discoverable. Which service deletes each copy, and how does the deletion system find that service? | Incomplete deletion | Both: F registers its stores; P makes registration part of provisioning |
| 4 | Expose an idempotent deletion interface. What is the deletion interface, and is it idempotent? | Over-deletion, incomplete deletion | Both: P defines it; F implements it |
| 5 | Recheck eligibility when deletion runs. When deletion runs, what is rechecked: holds, retention, current state? | Over-deletion | Both: F says what can make its data ineligible; P rechecks it when deletion runs |
| 6 | Decide the order. In what order are parts deleted, and what must outlive its parent? | Orphaned data | Both: F declares parents and children and rejects writes under deleted parents; P deletes bottom-up |
| 7 | Write down the deadline. What is the deadline, from which start event, and which copies expire, or wait for compaction, on their own clock? | Late deletion | Both: P records deadlines; F bounds its expiries |
| 8 | Budget the deletion load. What deletion load can the feature’s stores absorb, and who limits it? | Collateral load | Both: F states capacity; P enforces budgets |
| 9 | Plan for resurrection. How can deleted data come back, and what stops it? | Resurrection | Both: F refills caches only from current data; P handles tombstones and restore |
| 10 | Verify through a different path. How is completion verified without reusing the deletion path? | Incomplete deletion, unprovable deletion | Both: F provides an independent way to list its data; P runs verification |
| 11 | Keep evidence that does not recreate the data. What evidence is kept, and does it contain the personal data it shows was removed? | Unprovable deletion | Both: P keeps evidence; F keeps content out of its logs |
| 12 | Test deletion continuously. How is deletion of this feature’s data tested continuously? | Incomplete deletion, orphaned data, late deletion, unprovable deletion | Both: F supplies test scenarios; P runs canaries |
Table 2.
A completed checklist for a hypothetical “message reactions” feature; it does not describe how any particular product implements reactions. Row numbers match the items in Table 1.
Table 2.
A completed checklist for a hypothetical “message reactions” feature; it does not describe how any particular product implements reactions. Row numbers match the items in Table 1.
| # | Answer |
|---|---|
| 1 | Reaction records in the conversation store (primary). A per-message count in the message summary cache (derived; expires after a fixed period). A daily aggregate in the analytics store (derived; removed by its retention job). Replicas, a change log, and backups of the conversation store (secondary, inherited). |
| 2 | Each reaction belongs to its message and, through it, to the conversation; the reacting user is a second owner. Deleting a user removes that user’s reactions; deleting a conversation removes all reactions in it. |
| 3 | Registered as a conversation-scoped data type before the first write, so conversation and user cleanup discover it; deregistered only after its reactions are deleted. |
| 4 | DeleteReactions(scope), scope = message, conversation, or user within conversation, keyed by identifiers that are never reused; pages by continuation token; idempotent as in item 4. |
| 5 | Rechecks at execution, and again before each batch because a hold can arrive mid-cleanup, that the conversation or user is still deleted and not under a hold. |
| 6 | Reactions are removed before their messages. For user deletion, each reaction’s identifier is also recorded under the reacting user when the reaction is written, so cleanup can find it after the identity provider deletes the user; the record is dropped once the reaction is deleted. |
| 7 | Same deadline as messages: D days from the start event in the message policy. The cache TTL, the analytics retention, the conversation store’s compaction delay, and the backup and change-log lifetimes are each stated in days, all below D; cleanup must finish within D minus the longest. |
| 8 | Deletes are batched per conversation under the conversation store’s deletion budget; the store returns a throttling signal under load. |
| 9 | The cache is refilled only from the primary store, which returns nothing for deleted conversations, and a refill that raced the delete is removed by the cache’s expiry (row 7); reactions travel with conversations in migration and are covered by the store’s tombstones; replay and restore reapply conversation and user deletions from a log of pseudonymous identifiers, each entry kept until every older backup and change-log segment has expired. |
| 10 | A daily sample of conversations and users whose cleanup reported completion, or whose deadline passed without a hold. Each is checked for remaining reactions by querying the conversation store directly, by conversation or through its own index on the reacting user, not through cleanup’s enumeration or its per-user records (row 6). The canary (row 12) covers the other stores. |
| 11 | Conversation identifier, deletion time, per-store completion, any skip reason (such as a hold), verification result. No reaction content or user names; for user deletion, a pseudonymous user identifier kept on the evidence schedule. |
| 12 | Part of the synthetic conversation canary: create a test conversation and a test user with reactions, and delete each. Verify zero reactions in the primary store once cleanup reports completion, and in the cache, analytics store, and change log once each lifetime has passed; backups are covered by row 9. |
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.