Job search
Privacy Engineering Portfolio: Map Data Flows and Demonstrate Data Minimization
Connect an authored data-flow and necessity analysis to an executed local SQLite minimization lab, with functional comparisons, rejection tests and bounded deletion evidence.
A privacy engineering portfolio should connect a stated purpose to a data-flow decision, implemented controls and reproducible results. Show which fields you removed, why the remaining fields are necessary, and what still works afterward. Then test failure paths, retention and deletion, including derived data. A completed framework worksheet alone does not demonstrate that a system behaves as described.
LandOffer publishes this guide and offers a place to browse recent technical roles. We checked current NIST resources on October 23, 2026 and built the local synthetic experiment below. It uses Python's standard library, SQLite and invented tokens, with no real personal information, accounts, web service or external transmission. Its results concern the implemented local path, not production privacy or legal compliance.

Start with a purpose that can reject unnecessary fields
The NIST Privacy Engineering Program describes applying measurement science and systems engineering to privacy risks. For a portfolio, make that connection visible: a processing purpose should lead to a design choice and an observable test, rather than a diagram followed by a general claim that privacy improved.
Our self-authored equipment-pickup board has two selected functions: show workload by half-hour slot and service, and retrieve a reservation using its token. It supports only slots within the next 24 hours. These are invented product constraints, not requirements collected from an employer, a deployed appointment service or a legal retention rule.
An initially proposed overcollection design accepts ten business fields: token, service, slot, party size, name, email, phone, IP address, device fingerprint and free text. The ten-field architecture is an authored comparison design, not a previously running service or a captured production flow. We did execute a projection of three synthetic input records and a minimized local implementation. Label the unexecuted proposal and the executed minimized path separately in the portfolio.
The chosen functions do not need contact details or device analytics. The reduced scope omits email reminders, phone follow-up and name-based lookup; those functions would need separate requirements and design decisions. That is a deliberate scope decision, not evidence that every appointment product can remove contact information without affecting its requirements.
Complete the flow map and field-necessity record
NIST's privacy engineering resources describe PRAM as a tool for analyzing and prioritizing privacy risk. Its listed worksheets address business context, system design and a supporting data map, risk prioritization and control selection. Use that structure to connect an operation and possible individual impact to a chosen response; do not claim a formal PRAM assessment from a few field names.
Our completed authored decision record identifies unnecessary association of a reservation with identity and device information as a plausible concern. That is a risk hypothesis, not measured harm or a probability score. The implemented response is a strict four-field contract with constrained values, payload-free application logs and a defined retention/deletion path.
The completed maps separate the unexecuted proposal from the actual local path:
- Proposed before design, not run: hypothetical caller sends the unrestricted payload to a collector, raw database and raw log, then a slot report is produced.
- Implemented after path, run locally: trusted caller passes four fields to validation; accepted records enter the appointments table; a derived slot summary supports the workload view. A separate application log receives only event names, generic error codes and counts.
| Field or group | Completed necessity decision | Functional consequence |
|---|---|---|
| Name, email and phone | Reject; not needed for selected slot and token functions | No identity lookup, reminder or contact workflow |
| IP and device fingerprint | Reject; outside this local workload purpose | No network or device analytics |
| Free text | Reject; unbounded content is unnecessary here | No free-text support notes |
| Token | Retain with a restricted synthetic format for lookup and deletion | Still links activity within the lab; not anonymous |
| Service | Retain only pickup or return | Other service values rejected |
| Slot | Retain a UTC half-hour within the next 24 hours | No arbitrary minute or longer-horizon booking |
| Party size | Retain an integer from one through four | Larger parties and nested values rejected |
The local worked-assets/field-necessity.csv contains all ten original business fields and the two server-generated retention fields. Four accepted business fields do not mean the database has only four columns: created_at and expires_at administer the chosen retention policy. Show the two retention columns beside their purpose so a reviewer can reconcile the four-field input contract with the six-column appointment table.
Implement collection and logging boundaries
The local minimal_collector.py checks the exact input-key set, types, token shape, service enum, slot format and window, and party-size range. Unexpected fields reject the whole request; they are not silently saved for future use. The example's synthetic email and medical-note sentinels exercise that rejection path without using anyone's information.
The caller has already constructed the input in memory before validation. Therefore, the test demonstrates rejection before application persistence or payload logging, not prevention of every upstream collection. A real browser, reverse proxy, monitoring agent or request archive could introduce other data flows; none exists in this local implementation.
The application log records only event, optional generic code and optional count. It does not echo rejected values or reservation tokens. We inspected the resulting log and SQL dump for the selected rejected sentinel strings, and checked that accepted tokens were absent from the application log. The evidence covers the selected sentinel values and token strings in this run. It leaves other inputs, upstream logs and future logging changes untested.
NISTIR 8062, a January 2017 introduction to privacy engineering, treats processing as more than storage: logging, transformation and disposal are data actions too. Its discussion of manageability and disassociability helps explain why this project considers changes and unnecessary associations alongside access control. These concepts guide the design; they do not certify it.
Executed normal case: preserve the selected workload function
The first executed scenario inserts three invented records at an injected clock beginning October 1, 2026, noon UTC. demo-a1 is a two-person pickup at 14:00, demo-b2 a one-person pickup at 14:00, and demo-c3 a one-person return at 14:30. The tokens identify no real people, appointments or accounts.
| Slot and service | Actual materialized summary | Independent reference result |
|---|---|---|
| 14:00 UTC, pickup | Two bookings, three people | Two bookings, three people |
| 14:30 UTC, return | One booking, one person | One booking, one person |
| Total | Three bookings, four people | Three bookings, four people |
The reference groups the three authored ten-field records using ordinary Python arithmetic. Their four-field projections match the accepted fixtures, and the independent reference counts equal the SQLite summary. We also retrieved the first record and reopened the database to confirm that the active summary persisted across that restart.
This supports a narrow functional conclusion: the selected three-record count and token-lookup cases work without the six removed fields. It is not a benchmark against a running old service, a load test or a demonstration that all scheduling requirements survived. No reminder, identity-recovery or multi-user authorization feature was implemented.
The completed design asset is worked-assets/data-flow-and-decision.md. It states the purpose, before/after boundaries, field decisions, expected losses and remaining linkability. This differs from a GRC Current and Target Profile: the portfolio here includes executed code and concrete data-state changes, rather than organization-level targets awaiting implementation.

Executed failure case: reject, delete and expire
A separate group of checks exercises conditions that a successful count would miss. Extra email and free-text fields are rejected with no change to the application database. Invalid token and service values, a nested party size, a non-half-hour slot, an out-of-window slot and a duplicate token also exercise rejection. Error messages use generic codes rather than copying the submitted values.
The deletion case then removes demo-a1, the two-person record. Lookup returns no record, and the materialized pickup summary changes from two bookings and three people to one booking and one person. The return summary remains one booking and one person. The resulting total is two bookings and two people, not the original three bookings and four people.
Deleting the same token again returns zero and leaves the summary unchanged. This checks idempotent logical deletion in the implemented tables. Rebuilding the derived summary in the same SQLite transaction avoids leaving the removed record's contribution in that particular aggregate. It does not address external copies or a different analytics pipeline.
The independent TTL scenario starts with one reservation and a chosen retention period of 86,400 seconds from insertion. The injected clock tests the exact boundary without waiting a day:
| Time since insertion | Actual lookup result | Derived-data result |
|---|---|---|
| 86,399 seconds | Record present | Reservation still active |
| 86,400 seconds | Record absent | Slot summary empty after purge |
| 86,401 seconds | Record absent | No reappearance in lookup |
Expiration uses expires_at <= now. Purging happens when an operation calls the collector, including reads. There is no background scheduler: an idle database can retain expired rows until the next operation. State that limitation beside the result rather than implying autonomous deletion at the wall-clock instant.
These cases and the functional-impact record are completed in worked-assets/function-and-deletion-record.md. Together they form the second asset: implemented rejection, logical deletion, TTL behavior and the observed consequences for the selected function. They are not instructions to delete real customer data or a report of a production incident.
Package the evidence with the remaining gaps
The accompanying local report contains minimal_collector.py, run_lab.py and two raw result files. Running python3 run_lab.py from that report directory creates disposable local SQLite databases and logs, performs 25 assertions and prints the results. Both independent fresh-process runs passed and produced byte-identical output; the source hashes remained unchanged. The runner uses only the standard library and makes no network requests.
Give the reviewer the source, raw result files, injected clock values and expected summaries so each reported outcome can be replayed. The retained evidence includes the initial and post-deletion summaries, application log entries, TTL observations, fixture projection and independent count comparison. The script's output states its scope. These are local replay artifacts. Before sharing or hosting them, verify the intended package and access route; no public deployment or employer approval is claimed here.
Logical row removal is not verified physical erasure. SQLite free pages, journals, backups, exported reports, caller memory and other downstream copies were not assessed. The evidence deliberately retains original synthetic inputs for replay. The project also lacks production authentication, authorization, encryption, concurrency testing and a trusted-clock threat model; its token format is a lab constraint, not an access-control design.
Small-group counts and tokens can remain linkable. No re-identification study, anonymity guarantee or differential-privacy mechanism was tested. Describe the result as a scoped minimization implementation with observed trade-offs, not “GDPR compliant,” “fully anonymous” or “all data permanently deleted.”
A truthful portfolio summary is: “Built an isolated synthetic SQLite reservation collector; documented ten-to-four business-field selection, preserved three-record workload counts, and tested rejection, payload-free logs, derived-count updates and TTL boundaries.” Then compare recent roles on LandOffer with the specific implementation, review and risk-communication work this evidence demonstrates.
Download the worked example files
Download the curated educational companion. Read PUBLICATION-README.md after extraction for the public file layout, replay commands and requirements. The listed offline Python checks were rerun from the extracted archive in a disposable directory. The earlier local report and commands describe the original evidence environment; use the companion README for the portable layout. No whole evidence directory, credentials or compiler binaries are included.
Sources and Further Reading
- NIST: Privacy engineering — program scope and engineering resources.
- NIST: Privacy engineering resources and PRAM — business context, design/data map, prioritization and control-selection worksheets.
- NISTIR 8062 — January 2017 introduction; relevant engineering objectives and data-action discussion.


