skip to content

What must be stripped from a production record before it goes into a drafting prompt, and what must survive?

level: juniorimportance: should knowfreq 52%

answer

  1. Two things travel inside a real record
  2. One part is liability, one part is value
  3. Substitute values rather than deleting fields
  4. Same shape, same edges, no real person

basics

~20 s

Strip whatever identifies a person or grants access: names, contact details, account numbers, tokens and keys. Keep the shape - field set, formats, lengths, encodings, boundary values - because the shape is why a real record drafts better cases.

solid answer

~50 s

Two different things travel inside a production record, and only one of them is why you wanted it. The **identifying and credential-bearing** part - a person's name, address, contact details, account and card numbers, session identifiers, keys - is liability: once it enters a prompt it has left your controlled systems, it may be retained, and it may be readable by people with no basis to see it. The **structural** part is the reason a real record is valuable at all: the field set, the formats, the lengths, the optionality, the encodings, and the awkward values nobody invents - an optional field left empty, a surname wider than the column, a negative adjustment, a decimal separator that is a comma. Redaction that preserves structure means **substituting values of the same shape**, not deleting fields or blanking them. A record redacted into blandness drafts bland cases.

code

yaml · 19 lines
yaml
# raw record - never goes into a drafting prompt
customer:
  full_name:     "Aleksandra Nowak-Wisniewska"
  email:         "[email protected]"
  account_ref:   "8842019773"
  bearer:        "<live access token>"
  middle_name:   ""
  balance_minor: -1250
  locale:        "pl-PL"

# redacted for drafting - identity removed, shape preserved
customer:
  full_name:     "Malgorzata Brzezinska-Kowal"   # same script, same length band
  email:         "[email protected]"     # parseable, undeliverable
  account_ref:   "0000000000"                    # same length, same digits-only rule
  bearer:        null                            # field kept, value never real
  middle_name:   ""                              # empty optional kept, it is the edge
  balance_minor: -1250                           # negative balance kept, it is the edge
  locale:        "pl-PL"                         # drives formatting, kept verbatim

go deeper

for a junior

Be ready to name what never enters a prompt: real people's details, account numbers, and anything that grants access. Know that a credential pasted into a chat window is a leaked credential even if it expires tomorrow.

for a middle

Explain the split: strip identity and credentials, preserve structure. Give concrete examples of structure worth keeping - formats, lengths, optionality, encodings, boundary values - and say why a record redacted into blandness produces bland drafts.

for a senior

An interviewer expects the process answer: a checked, versioned sample set produced once from production shape and stored where drafting reaches it, so nobody redacts by hand under pressure. Say how you know the samples still match production.

for a principal

Own the obligation. Which data classes may leave the boundary at all, what your retention and processing position actually is, and how you make the compliant path the convenient one instead of a rule people quietly route around.

## Why a real record is tempting in the first place Nobody reaches for production data purely out of laziness. A real record carries information no one invents: the field that is always present in the schema and empty in four rows out of ten, the surname longer than the column the interface reserved for it, the amount that arrives negative because a refund was posted against it, the locale that formats decimals with a comma, the identifier that is a run of digits and must never be parsed as a number. A case drafted from a real record exercises those. A case drafted from an imagined record exercises a tidy world that does not exist. **The value of the record is its shape, and its shape is not the part you have to protect.** That is the whole insight this leaf turns on. Redaction is not a tax on usefulness; done properly it removes only the part that was never useful. ## What must never enter the context Two categories, and they fail in different ways. - **Identity.** Names, addresses, contact details, dates of birth, account and card numbers, device identifiers, and free-text fields where people write about themselves. The moment this enters a prompt it has left your controlled systems: it may be retained, it may be read by colleagues with no basis to see it, it may cross a border, and it now sits somewhere your data inventory does not describe. Whether that processing was lawful is decided by the nature of the record, not by the tool's promises. - **Credentials.** Tokens, keys, session identifiers, signed links and one-time codes still inside their validity window. These do not merely describe; they *grant*. A shortened credential is not a safe credential - a prefix frequently identifies the issuing system and the holder, and truncation is not redaction. Free-text is where careful teams still get caught. A `notes` field on a support record is one person writing an unstructured paragraph about another person, and no field-level rule catches it. ## What has to survive | Property worth keeping | Why a draft needs it | Cheap substitute | |---|---|---| | Full field set, empty optionals included | Empty optionals are the edge a draft otherwise skips | Keep the key, empty the value | | Format and length | Truncation and validation defects live here | Same length, same alphabet, invented | | Encoding and script | Characters outside the plain alphabet break collation and display | A name in the same script | | Cardinality | One line item and two hundred are different cases | Keep the count, change the contents | | Boundary and awkward values | Negative, zero, maximum, already expired | Keep the value; it identifies nobody | | Relationships | A record with three linked accounts drafts differently | Keep the arity | Read the right-hand column as the technique in one word: **substitute, do not delete.** Deleting a field makes production look tidier than it is. Replacing every value with `xxx` erases exactly the properties that made the record worth having. Both produce a sample that teaches a drafting model about a system nobody operates. ## Make the safe path the convenient one Hand redaction is a control that depends on care under time pressure, which means it fails eventually. The durable version is to produce the sample set once, deliberately: 1. Take an extract inside the boundary where the data is already permitted to live. 2. Substitute identity and credential fields with generated values of the same shape, using a consistent mapping so relationships between records survive. 3. Have a second person check a sample of the output, looking hardest at free-text fields. 4. Store the result, versioned, where anyone drafting can reach it in a single step. 5. Refresh it on a schedule, because production shape drifts and a two-year-old sample teaches yesterday's edges. Now the compliant artefact is also the fastest one to reach for, which is the only arrangement that survives contact with a deadline. ## The two ways this goes wrong The obvious failure is under-redaction: a live record pasted in because it was already in a window and the request was urgent. The controls are the ordinary ones - training, a place to get safe samples, and honesty that a retention promise is one layer of defence rather than the whole answer. The quieter failure is over-redaction, and it is never reported as a failure. Every string becomes `test`, every amount becomes `100`, every name becomes `User One`, and the drafts that come back cover the happy path and nothing else. Because the record was safe and the process was followed, nobody logs a problem; the suite simply stops finding anything interesting. So when you review a sample set, ask what the ugliest value in it is. If there is no ugly value, the redaction removed more than it needed to.

  • Your redacted sample keeps the shape but every value is now bland. What did you lose?
    The edges. Real records carry the values nobody invents: an empty optional field, a name that overflows its column, a zero-quantity line, an offset with minutes in it. Bland substitutes draft cases that only walk the happy path, so choose substitutes that keep each awkward property while changing the identity.
  • Can you skip redaction if the tool promises not to train on your input?
    No. A retention promise is one control among several. It says nothing about who inside your own organisation reads the transcript, what gets logged along the way, or what a breach exposes, and data-protection duties attach to the record rather than to the promise. Redact first and treat the promise as defence in depth.
  • Who should be doing the redaction - the engineer drafting, or something earlier?
    Earlier, wherever you can. A hand-redacted paste is a control that fails the first time somebody is in a hurry. A generated sample set - produced once from production shape, checked, versioned and stored where anyone drafting reaches it in one step - makes the safe artefact the convenient one.

It is the difference between blacking out a form and re-typing it with invented answers: the blacked-out copy tells you nothing about what fits in the boxes.

saying these in an interview costs you the question

  • Pastes a live record and relies on the tool's retention promise
  • Replaces every field with placeholder text, losing all shape
  • Deletes optional fields instead of substituting safe values
  • Thinks masking the name is enough while identifiers remain
  • Treats a credential in an example as harmless because it expires