Data Retention

Define retention once, enforce it automatically.

Define data retention policy once, per data category. Avaril enforces deletion and anonymization automatically, in line with DPDPA erasure obligations — without relying on manual cleanups or missed jobs.

Retention clusters

Every regulatory privacy compliance requires one solid pipeline.

Categories, policies, and systems drawn as one graph. Drag a node, scroll to zoom, and click a cluster to see how long its data lives — and what happens when that time is up.

Retention policy

Plan before your execution.

Define your Data Retention Policy before you touch anything else — a retention SDK, a deletion job, or an audit run only makes sense against a policy that already exists.

Pick a data category, set how long it can be kept, what happens when the period ends, and the legal basis that justifies it — once, per category.

Policy definition

Draft

Data categorykyc_documents

Retention period8 years

Deletion methoddelete

Legal basisPMLA record-keeping

Saved rules are enforced automatically at the point of expiry — no manual purge jobs, nothing to remember.

Developer SDK

Retain your elements via SDK.

Register retention calls directly in the code paths that handle personal data — a retain call on ingest, a deletion or anonymization trigger at expiry. The SDK checks that every category you declared actually has a policy behind it.

Image placeholder

Policy checks enabled

Enforce the privacy regulatory rules in your software.

Processing activities aren't just records in a workspace. Declare them in code with the SDK, then let the CLI catch the moment your software drifts from what's declared.

import avaril
from avaril import AvarilClient
from .services import LoginService
client = AvarilClient(publishable_key="av_pk_live_...")
service = LoginService()
@avaril.process(id="authentication_process", client=client)
def handle_login(request):
    avaril.consent_trigger()
    response = service.function_login(request)
    avaril.retain(request.id)
@avaril.process(id="authentication_signout_process",client=client)
def signout(request):
    avaril.consent_trigger()
    service.function_signout(request)
    avaril.deletion_trigger(request.id)

Declare privacy where the data is processed

Define processing activities directly in your application code. Associate workflows with the data they handle, the purpose of processing, and the privacy controls that should apply—creating a structured representation of what your software actually does.

Detect privacy drift before it reaches production

Compare what your application declares with what has been deployed. Use Avaril's CLI to validate processing definitions, identify unexpected changes, and surface privacy drift before it becomes an operational or compliance problem.

End of the line

Have your own type of deletions.

When a retention period ends, Avaril applies the deletion method you declared per category — irreversible when the data must disappear, reversible only where it must not.

Lossy

Anonymization

A lossy, irreversible transformation. Identifiers are stripped or perturbed so the record can no longer be attributed to a person — and there is no key to undo it.

Lossless · reversible with key

Encryption

Reversible, key-based protection. The data carries no usable identifiers without the key, and it can only be recovered — indefinitely or until you destroy the key and count as deleted — by someone who holds it.

Choose it when the data must return later (e.g. cross-border or archival holds); choose anonymization when it must never be re-identifiable.

One solid pipeline

Visualize your pipeline.

Increase the scope of auditability in decision making.

Sync / Flag implementations

The SDK keeps what your code declares in sync with the workspace, and flags processing that runs against a category with no live retention policy behind it.

Categorize and identify the possibility

Data is matched to categories as it is ingested, and every category carries its retention possibility — how long it may live, and what its lawful end states are.

Pending capability

Coming soon.

Retention, everywhere

Beyond deletions.

Retention obligations don't stop at your primary datastore — the places that exist to preserve data need retention rules most.

Auditability

Audit logs aren't disposable — every enforcement action, grant, and exception must itself be retained, so the record of what you deleted survives as long as you can be questioned about it.

Backups

Backups outlive the systems they copy. Each backup needs an expiry of its own, and deletions must propagate to the next backup generation — or they silently resurrect data you already erased.

Limited Beta Access

Build Privacy Governing Workflows Faster business-ready?

Built for Startups and MSMEs navigating Privacy legal compliance, privacy operations, and consent management at scale.

No spam, ever. We'll only send you product updates.

Request Feature Join Discord Community View Roadmap