
Disclosure: I work at Blue Copper Technologies, which helps organisations with DPDP Act compliance. This post was drafted with AI assistance and reviewed by me. It is general information, not legal advice. Last updated 20 November 2026.
TL;DR
Under India’s DPDP Rules, 2025, every personal data breach must be reported to each affected person and to the Data Protection Board without delay, with a detailed report to the Board within 72 hours. Many incidents must also reach CERT-In within 6 hours. There is no “low risk, skip it” exception. Your engineering team needs three things ready before the incident: a clock that starts on detection, a query that finds affected people, and templates that fill themselves from the incident record.
The Act comes into full force on 13 May 2027. That date is fixed, and every organisation must be compliant by then.
Which clocks start when you find a breach?
Two regimes apply to many Indian systems, and they start at different moments.
- CERT-In, 6 hours: the CERT-In Directions of 28 April 2022 require specified cyber incidents (data breaches and leaks, unauthorised access, compromise of critical systems, ransomware and others) to be reported to CERT-In within 6 hours of noticing them.
- Data Protection Board, “without delay”: a first intimation describing the breach, its nature, extent, timing, location and likely impact.
- Data Protection Board, 72 hours: a detailed report with the facts, the cause, mitigation, any findings about who caused it, remedial steps, and a report on the notices sent to affected people. The Board can allow more time on a written request.
- Each affected person, “without delay”: a plain notice of what happened, the likely consequences, what you are doing, what they can do, and a contact who can answer.
Treat “aware of the breach” as the moment a human confirms that personal data may have been exposed. Do not wait for the investigation to finish. Failing to notify the Board and affected people can draw a penalty of up to ₹200 crore under the Act’s Schedule.
Step 1: Make the incident record the single source of truth
Every later step reads from one record. Keep it in a repo or a ticket with a fixed schema, not in a chat thread.
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
@dataclass
class BreachIncident:
incident_id: str
detected_at: datetime # when a human confirmed possible exposure
systems: list[str]
data_categories: list[str] # e.g. ["email", "phone", "pan"]
description: str = ""
cause: str = "under investigation"
mitigation: list[str] = field(default_factory=list)
affected_count: int | None = None
cert_in_reported_at: datetime | None = None
board_intimated_at: datetime | None = None
board_report_at: datetime | None = None
principals_notified_at: datetime | None = None
def deadlines(self) -> dict[str, datetime]:
return {
"cert_in": self.detected_at + timedelta(hours=6),
"board_detailed_report": self.detected_at + timedelta(hours=72),
}
def overdue(self, now: datetime | None = None) -> list[str]:
now = now or datetime.now(timezone.utc)
late = []
d = self.deadlines()
if self.cert_in_reported_at is None and now > d["cert_in"]:
late.append("CERT-In report")
if self.board_report_at is None and now > d["board_detailed_report"]:
late.append("Board detailed report")
return late
“Without delay” has no number, so the code gives it none. Track it as a separate timestamp and treat any gap of more than a few hours as something you will have to explain.
Step 2: Put the clock where people will see it
A deadline that lives in a document gets missed at 3 a.m. Post it to the incident channel the moment the record is created, and again on a schedule.
def clock_message(inc: BreachIncident) -> str:
d = inc.deadlines()
fmt = "%d %b %H:%M UTC"
lines = [
f"Incident {inc.incident_id}: personal data breach response started",
f"CERT-In report due by {d['cert_in'].strftime(fmt)}",
f"Board detailed report due by {d['board_detailed_report'].strftime(fmt)}",
"Board intimation and user notices: without delay",
]
late = inc.overdue()
if late:
lines.append("OVERDUE: " + ", ".join(late))
return "\n".join(lines)
Run it from your alerting tool or a cron job every hour until all four timestamps are filled. Use UTC everywhere and convert to IST only in the message, if your team prefers.
Step 3: Find the affected people with a query you wrote in advance
The 72-hour report and the user notices both depend on one answer: whose data was exposed? Writing that query during the incident is slow and error-prone. Write it now, test it on a past access window, and keep it next to the runbook.
-- Data principals whose records were read by a suspect identity in the window
SELECT DISTINCT a.data_principal_id,
p.preferred_language,
p.contact_email
FROM access_log a
JOIN principals p ON p.id = a.data_principal_id
WHERE a.actor_id = ANY(:suspect_actor_ids)
AND a.accessed_at BETWEEN :window_start AND :window_end
AND a.resource_type IN ('profile', 'kyc_document', 'payment_method');
This only works if access to personal data is logged per record, with the actor and time. The DPDP Rules already ask for logs of personal data processing to be kept for at least one year, and CERT-In asks for ICT logs to be kept for 180 days within India. If your logs cannot answer “who read this person’s data”, fix that first. In our DPDP Act sessions with five leading hospitals in Eastern India, having no breach process at all was one of the ten risks we almost always found.
Step 4: Generate notices from the record
Notices to people must be clear and plain, and the Act lets people ask for information in English or any language in the Eighth Schedule to the Constitution. Keep templates per language and fill them from the incident record, so legal reviews one template, not three hundred emails.
from string import Template
NOTICE_EN = Template("""Subject: Important: a security incident involving your data
On $date we found that $what. The information involved: $categories.
What this could mean for you: $impact
What we have done: $mitigation
What you can do: $user_steps
Questions? Contact $contact_name at $contact_email.""")
def render_notice(inc: BreachIncident, impact: str, user_steps: str,
contact_name: str, contact_email: str) -> str:
return NOTICE_EN.substitute(
date=inc.detected_at.strftime("%d %B %Y"),
what=inc.description,
categories=", ".join(inc.data_categories),
impact=impact,
mitigation="; ".join(inc.mitigation) or "we are containing the incident",
user_steps=user_steps,
contact_name=contact_name,
contact_email=contact_email,
)
Send from a domain and address your users already recognise, and say in the notice that you will never ask for passwords or OTPs. Breach notices are a favourite template for phishing.
Step 5: Build the 72-hour report as you go
The detailed report to the Board asks for things your team produces anyway during the response. Capture them in the incident record as they happen:
- Facts and timeline: detection time, first access by the attacker if known, containment time.
- Cause: the vulnerability, misconfiguration or human error, once known. “Under investigation” is acceptable early on.
- Mitigation: credentials rotated, access revoked, systems isolated, patches applied.
- Findings about who caused it: an internal user, a vendor, an external actor, or unknown.
- Remedial steps: what prevents a repeat.
- Notices sent: how many people were told, when and through which channel.
If the investigation is still open at 72 hours, send what you have and ask the Board in writing for more time. A late report with a clear reason reads better than a complete one that arrives on day five.
Step 6: Rehearse with a fake breach
Run a tabletop exercise once a quarter. Pick a realistic scenario, such as a support agent’s account used to export customer KYC files, and time each step:
- Detection to confirmed incident record.
- Record to CERT-In report drafted.
- Record to affected-people list from the Step 3 query.
- List to notices rendered in each language you support.
- Everything to a draft 72-hour report.
Often the slowest step has nothing to do with code: it is finding who is allowed to approve the notice. Name that person, and a backup, in the runbook.
What this runbook does not cover
- Legal judgement: whether an event is a “personal data breach” in a borderline case needs your privacy lead or counsel.
- Vendor breaches: if a processor is breached, you are still the one who must notify. Your contracts need a notice clause short enough to fit your 6-hour and 72-hour clocks.
- Other regimes: sector regulators such as RBI, SEBI or IRDAI, and laws such as GDPR, have their own clocks. Add them to the deadlines() method if they apply to you.
Checklist for your next sprint
- An incident record schema exists in the repo, with the timestamps above.
- A deadline bot posts the CERT-In and Board clocks to the incident channel.
- The affected-people query is written, tested and stored with the runbook.
- Per-record access logs exist and are kept for at least one year.
- Notice templates exist for each language your users use.
- A named approver and backup can sign off notices within hours.
- A tabletop exercise has been run in the last quarter.
References
- Digital Personal Data Protection Act, 2023 (MeitY)
- Digital Personal Data Protection Rules, 2025 (MeitY), Rule 6 (safeguards and logs) and Rule 7 (breach intimation)
- CERT-In Directions under Section 70B(6), 28 April 2022
- NIST SP 800-61, Computer Security Incident Handling Guide
How long would your team take today to list every person affected by a leaked admin account? Tell me in the comments.
Gayatri Chakrabarty works at Blue Copper Technologies, a technology company in Kolkata, India, that helps organisations prepare for the DPDP Act. To see where your systems stand, try the free DPDP readiness check or get in touch with the team.
Top comments (0)