From Lines of Code to Lines of Policy? Exploring Software Developers’ Perceptions of Their Privacy Policy–Related Activities

Ria Prianka Saha (Paper author · Technical University of Darmstadt), Daniel Stäcker (Paper author · Technical University of Darmstadt), Jonas Stromberg (Paper author · Fraunhofer IGD), Steven Lamarr Reynolds (Paper author · Fraunhofer IGD), Kilian Demuth (Paper author · Technical University of Darmstadt - PEASEC), Frank Nelles (Paper author · Technical University of Darmstadt - PEASEC), Christian Reuter (Paper author · Technical University of Darmstadt - PEASEC), Jörn Kohlhammer (Paper author · Fraunhofer IGD), Alexander Benlian (Paper author · Technical University of Darmstadt)

Privacy Enhancing Technologies Symposium (PETS) 2026 · Day 2 · Caribou

Overview

In the realm of digital products, a pervasive and critical issue continues to undermine user trust and regulatory compliance: the significant disparity between a software's stated privacy policy and its actual data handling practices. This fundamental mismatch, often leading to situations where policies claim no data collection while third parties silently gather extensive user information, has profound implications for transparency, user confidence, and adherence to stringent privacy regulations like the GDPR. The consequences can range from eroding user trust to substantial financial penalties for non-compliance.

Watch on YouTube · Slides

Visual summary for From Lines of Code to Lines of Policy? Exploring Software Developers’ Perceptions of Their Privacy Policy–Related Activities by Ria Prianka Saha, Daniel Stäcker, Jonas Stromberg, Steven Lamarr Reynolds, Kilian Demuth, Frank Nelles, Christian Reuter, Jörn Kohlhammer, Alexander Benlian
Visual summary for From Lines of Code to Lines of Policy? Exploring Software Developers’ Perceptions of Their Privacy Policy–Related Activities by Ria Prianka Saha, Daniel Stäcker, Jonas Stromberg, Steven Lamarr Reynolds, Kilian Demuth, Frank Nelles, Christian Reuter, Jörn Kohlhammer, Alexander Benlian

Key moments

  1. 0:00 Introduction: Mismatch between privacy policies and software behavior
  2. 2:00 Investigating developers' role and research questions
  3. 5:00 Alignment: Privacy policy adapts to software behavior
  4. 6:00 Alignment: Software behavior adapts to privacy policy
  5. 7:00 Perceptions of symbolic compliance over real privacy
  6. 8:00 Discussion: Misalignment cycle and key contributions
  7. 9:00 Recommendations for developers and organizations

From Lines of Code to Lines of Policy? Exploring Software Developers’ Perceptions of Their Privacy Policy–Related Activities

Speakers: Ria Prianka Saha (Paper author, Technical University of Darmstadt); Daniel Stäcker (Paper author, Technical University of Darmstadt); Jonas Stromberg (Paper author, Fraunhofer IGD); Steven Lamarr Reynolds (Paper author, Fraunhofer IGD); Kilian Demuth (Paper author, Technical University of Darmstadt - PEASEC); Frank Nelles (Paper author, Technical University of Darmstadt - PEASEC); Christian Reuter (Paper author, Technical University of Darmstadt - PEASEC); Jörn Kohlhammer (Paper author, Fraunhofer IGD); Alexander Benlian (Paper author, Technical University of Darmstadt)

Conference: PETS

YouTube: https://www.youtube.com/watch?v=C5yomBZItlM

Overview

In the realm of digital products, a pervasive and critical issue continues to undermine user trust and regulatory compliance: the significant disparity between a software's stated privacy policy and its actual data handling practices. This fundamental mismatch, often leading to situations where policies claim no data collection while third parties silently gather extensive user information, has profound implications for transparency, user confidence, and adherence to stringent privacy regulations like the GDPR. The consequences can range from eroding user trust to substantial financial penalties for non-compliance.

The talk, presented by Ria Prianka Saha from the Technical University of Darmstadt, delves into this challenge by focusing on a crucial, yet often overlooked, stakeholder: the software developer. Titled "From Lines of Code to Lines of Policy? Exploring Software Developers’ Perceptions of Their Privacy Policy–Related Activities," this research investigates how developers perceive their role in ensuring the alignment between privacy policies and software behavior. It also explores the organizational factors that either facilitate or impede this alignment, offering a unique perspective on the root causes of the problem and proposing practical recommendations for fostering genuine privacy compliance.

The importance of this research cannot be overstated. Software developers are at the forefront of implementing data handling functionalities, and their daily coding decisions directly determine whether a product's behavior lives up to its privacy promises. By understanding their perspectives, challenges, and the organizational pressures they face, we can identify more effective strategies to bridge the gap between policy rhetoric and technical reality, ultimately strengthening privacy protection in the digital landscape.

Background

▶ Watch: Introduction: Mismatch between privacy policies and software behavior (0:00)

The problem of privacy policy-software behavior misalignment is a well-documented concern within the privacy research community. Numerous studies have highlighted instances where privacy policies are either outdated, misleading, or simply fail to reflect the true data flows and processing activities occurring within an application. This discrepancy is not merely a semantic issue; it strikes at the core of informed consent and user autonomy, as individuals are unable to make genuine choices about their data if the information provided to them is inaccurate. Regulatory frameworks, particularly the General Data Protection Regulation (GDPR) in Europe, explicitly mandate that personal data handling practices must be communicated transparently and truthfully to users. Failure to do so constitutes a direct violation, exposing organizations to significant legal and reputational risks.

While prior research has broadly examined privacy-related changes in software development, this study distinguishes itself by specifically investigating the developers' perspective on their role in achieving this critical alignment. Developers are uniquely positioned within the Software Development Life Cycle (SDLC). They are the ones translating high-level requirements into functional code, making decisions about data collection, storage, processing, and sharing. Their "foundational coding efforts" are the bedrock upon which all digital products operate, and thus, their understanding, capabilities, and the environment in which they work are paramount to ensuring privacy compliance.

The research was motivated by the recognition that developers are often "formally responsible" for implementing privacy-related tasks, yet the mechanisms and support structures for them to effectively do so are frequently inadequate. The study aimed to uncover how developers perceive their contribution to alignment and, crucially, how they perceive organizational factors that lead to symbolic compliance – where an organization appears to comply with privacy regulations on the surface (e.g., by having a policy) but fails to implement substantive changes in its software behavior. This distinction between symbolic and substantive alignment is critical for understanding why the mismatch persists despite regulatory pressures.

Key Findings

▶ Watch: Alignment: Privacy policy adapts to software behavior (5:00)

To address their research questions, the authors adopted a qualitative approach, conducting 15 semi-structured interviews with software developers. These developers were selected based on their basic awareness of privacy policy requirements for the software they worked on. The recruitment process involved leveraging the crowdsourcing platform Prolific for 11 participants and professional networks for an additional 4. The final sample was diverse, spanning five European countries, eight different industries, and organizations ranging from small to large. This broad representation allowed the researchers to capture varied organizational contexts while maintaining a manageable regulatory scope, primarily focusing on the GDPR. The interview data was then analyzed using an inductive coding approach, leading to the identification of three core dimensions or categories of findings.

The first two dimensions highlight the bidirectional nature of alignment activities undertaken by software developers:

  1. Policy Adapts to Software Behavior: This category captures instances where changes in the software's data handling practices necessitate updates to the privacy policy. Developers are often the first to know when new customer data is collected or existing data is used in a novel way. As one developer eloquently stated, "If I'm going to gather more customer data, I will put it through the others, put it through the team. I wouldn't sort of just do it myself without telling anyone." This demonstrates a perceived responsibility to inform relevant stakeholders (like legal or privacy teams) when technical changes impact policy. However, the efficacy of this "putting it through" process is often hindered by the absence of formal, well-defined mechanisms.
  1. Software Adapts to Policy Changes: Conversely, this dimension describes situations where modifications or updates to the privacy policy (e.g., due to legal revisions) require corresponding changes in the software's behavior. Here, the developer's role is to translate legal requirements into concrete software requirements. Another developer illustrated this by explaining, "When the policy changes, for example, when legal revise the policy, it was the software developers responsibility together with an another architect to turn these legal requirements into two software requirements." This emphasizes the critical translation layer that developers provide, bridging the gap between legal text and executable code.

The third, and arguably most critical, dimension identified was the developers' perception of symbolic compliance rather than genuine adherence to privacy principles within their organizations. This "attention" category reveals a systemic issue where business interests frequently supersede privacy considerations. Developers observed a lack of adequate resources—including time, budget, and expertise—dedicated to privacy-related tasks. A poignant quote from a developer summarized this sentiment: "The main thing would be to get the lawyers and the privacy team to care most about privacy and not just about protecting the business." This highlights a pervasive skepticism among developers regarding the organization's true commitment to privacy, suggesting that legal and privacy teams are often perceived as primarily safeguarding the company from fines rather than proactively ensuring user privacy.

These three categories collectively illustrate a "misalignment cycle" driven by the prioritization of business interests over privacy, coupled with insufficient resource allocation. The research clearly demonstrates that while developers are aware of their responsibilities and engage in alignment activities, the lack of formal processes and organizational support often renders these efforts insufficient, leading to the persistent gap between policy and practice.

Technical Deep Dive

▶ Watch: Alignment: Software behavior adapts to privacy policy (6:00)

While the talk itself presents a qualitative study of developer perceptions rather than a new technical solution or architecture, its findings offer crucial insights into the technical challenges and implications of privacy policy-software behavior alignment. The core technical issue highlighted is the absence of robust, formalized processes that ensure privacy considerations are embedded throughout the Software Development Life Cycle (SDLC).

When developers are tasked with "turning legal requirements into software requirements," this is a profoundly technical undertaking. It involves:

  • Data Flow Mapping: Understanding exactly which data points are collected, where they originate, how they are processed, stored, and shared with internal or external systems (e.g., third-party APIs, analytics platforms).
  • Access Control Mechanisms: Implementing granular controls to ensure only authorized personnel or systems can access specific types of personal data.
  • Data Minimization: Designing systems to collect only the data strictly necessary for a given purpose, a core principle of GDPR.
  • Purpose Limitation: Ensuring that collected data is only used for the purposes explicitly stated in the privacy policy.
  • Data Retention Policies: Implementing automated or manual processes to delete data once its retention period expires.
  • Security Controls: Applying appropriate technical and organizational measures to protect personal data from unauthorized access, disclosure, alteration, or destruction.
  • Privacy-Enhancing Technologies (PETs): Potentially integrating techniques like anonymization, pseudonymization, or differential privacy where applicable, though these are often complex and require specialized expertise.

The study points out that "formal processes are often absent in organizations" for maintaining privacy policy accuracy over time. Technically, this translates to a lack of:

  • Automated Privacy Checks: Tools that can scan code or runtime behavior for deviations from privacy policies. This could include static application security testing (SAST) tools configured for privacy, or dynamic application security testing (DAST) tools monitoring data egress.
  • Privacy Test Cases: Dedicated unit, integration, and end-to-end tests specifically designed to verify privacy requirements. For example, a test case might confirm that a specific data field is not transmitted to a third-party analytics provider unless explicit user consent is given, or that data is correctly purged after a user account deletion request.
  • Data Governance Frameworks: Technical frameworks that enforce data classification, ownership, and lifecycle management within the software's architecture.
  • Version Control for Privacy Policies and Requirements: While code is versioned, privacy requirements linked to specific code versions are often not, leading to discrepancies when code evolves.

The recommendation to "integrate privacy checks or privacy test cases early into the software development process" is a direct call for technical intervention. This aligns with the principles of Privacy by Design, advocating for privacy considerations to be baked into the software architecture from the outset, rather than being an afterthought. Such integration would typically involve:

  • Privacy Threat Modeling: During the design phase, identifying potential privacy risks and designing technical controls to mitigate them.
  • Automated Policy Enforcement: Exploring the use of policy-as-code approaches where privacy rules are defined in a machine-readable format and automatically enforced by development tools or runtime environments.
  • Developer Training: Equipping developers with the technical knowledge and best practices for implementing privacy-preserving code, including secure coding principles relevant to data handling.

Furthermore, the finding that "poorly resourced" teams lack "time, budget, and expertise" directly impacts technical implementation. Without sufficient time, developers may resort to quicker, less privacy-preserving solutions. Without budget, organizations cannot invest in specialized privacy tools or training. Without expertise, developers may unknowingly introduce privacy vulnerabilities or fail to implement robust controls. The perception that legal teams are primarily concerned with "protecting the business" rather than "privacy" itself can lead to a disconnect where legal requirements are interpreted minimally, resulting in technically compliant but not truly privacy-enhancing implementations. This can manifest as technical debt in the privacy domain, where shortcuts taken for expediency accumulate into significant compliance risks over time.

Demo / Proof of Concept

▶ Watch: Discussion: Misalignment cycle and key contributions (8:00)

The presented talk was a research paper outlining the findings of a qualitative study. As such, it did not include a live demonstration or a technical proof of concept. The focus was on presenting the methodology, the discovered perceptions of software developers, and the resulting recommendations for improving privacy policy-software behavior alignment.

Defensive Implications

▶ Watch: Recommendations for developers and organizations (9:00)

The insights gleaned from this research offer critical guidance for security and privacy defenders seeking to bridge the gap between privacy policies and actual software behavior. The core implication is that privacy engineering must be deeply integrated into the development process, moving beyond mere legal compliance to foster a culture of substantive privacy.

  1. Formalize Privacy in the SDLC: Organizations must establish clear, documented processes for privacy throughout the entire software development lifecycle. This includes:
  • Privacy Requirements Gathering: Integrating legal and privacy experts into the initial stages of project planning to define privacy requirements alongside functional and security requirements.
  • Privacy by Design (PbD) Frameworks: Adopting a structured approach to embedding privacy principles into the design and architecture of software, rather than bolting them on later. This includes explicit consideration of data minimization, purpose limitation, transparency, security, and user control.
  • Data Inventory and Mapping: Maintaining up-to-date inventories of all personal data processed by each application, including its source, purpose, storage location, and recipients. Tools for automated data discovery and data flow mapping can significantly aid this.
  1. Empower Developers with Tools and Training: Developers are key, but they need support.
  • Privacy-Focused Training: Provide continuous training on privacy principles, relevant regulations (like GDPR), and secure coding practices specific to data handling.
  • Automated Privacy Checks: Integrate Static Application Security Testing (SAST) and Dynamic Application Security Testing (DAST) tools that can identify privacy-related vulnerabilities or deviations from data handling policies. This could involve custom rulesets for detecting unencrypted data in transit, unauthorized data egress, or excessive data collection.
  • Privacy Test Cases: Develop and enforce the use of dedicated privacy test cases within unit, integration, and system testing. These tests should validate compliance with specific privacy requirements, such as consent mechanisms, data deletion requests, or data access controls.
  • Clear Privacy Roles: Define explicit privacy responsibilities within development teams, potentially designating "Privacy Champions" who can act as liaisons between engineering and legal/privacy teams.
  1. Strengthen Cross-Functional Collaboration: The "misalignment cycle" is often a communication breakdown.
  • Early Legal Engagement: Legal and privacy teams should proactively engage with development teams from the project's inception, providing guidance on regulatory requirements and helping translate them into actionable technical specifications. This fosters a shared understanding and prevents legal interpretations from becoming disconnected from technical reality.
  • Dedicated Privacy-Engineering Liaisons: Establish roles or processes to facilitate ongoing dialogue between legal, product management, and engineering, ensuring that policy changes are promptly communicated and technical implications are understood.
  • Shared Objectives: Shift the organizational mindset from viewing privacy as a legal burden to a core product feature and competitive advantage, aligning the goals of legal, business, and engineering teams.
  1. Resource Allocation for Privacy: Organizations must allocate sufficient time, budget, and expertise to privacy-related tasks. This includes:
  • Dedicated Privacy Engineering Budget: Funding for tools, training, and potentially specialized privacy engineers.
  • Time for Privacy-Focused Development: Acknowledging that implementing robust privacy controls takes time and building this into project timelines.
  • Access to Expertise: Ensuring developers have easy access to privacy experts (internal or external) for consultation during design and implementation.

By implementing these defensive strategies, organizations can move beyond symbolic compliance towards a robust framework where privacy policies are genuinely reflected in the software's behavior, fostering user trust and ensuring regulatory adherence.

Key Takeaways

  • The Mismatch is Pervasive: A significant and problematic gap exists between stated privacy policies and actual software data handling practices, undermining transparency, user trust, and regulatory compliance (e.g., GDPR).
  • Developers are Central, Yet Challenged: Software developers are foundational to ensuring privacy alignment, but they often lack the formal processes, time, budget, and expertise needed to effectively translate privacy policies into code.
  • Alignment is Bidirectional: Developers perceive their role in both adapting privacy policies when software behavior changes (e.g., new data collection) and adapting software behavior when privacy policies are updated (e.g., legal revisions).
  • Symbolic Compliance is a Major Hurdle: A critical finding is the prevalence of "symbolic compliance," where business interests are prioritized over genuine privacy, leading to insufficient resource allocation and a perception that legal/privacy teams focus more on liability protection than actual user privacy.
  • Formal Processes and Collaboration are Essential: The absence of clear, formal processes for integrating privacy throughout the SDLC and a lack of early, strong collaboration between legal and development teams are key contributors to misalignment.
  • Proactive Integration is Key: To achieve substantive alignment, organizations must integrate privacy checks, privacy test cases, and legal team involvement early and continuously into the software development process.

About the Speaker(s)

Ria Prianka Saha is affiliated with the Technical University of Darmstadt in Germany, where she is engaged in research concerning privacy and software development. In this talk, she presented joint work exploring software developers' perceptions of their privacy policy-related activities. Her research, conducted with co-authors Daniel Stäcker, Jonas Stromberg, Steven Lamarr Reynolds, Kilian Demuth, Frank Nelles, Christian Reuter, Jörn Kohlhammer, and Alexander Benlian—representing both the Technical University of Darmstadt (including its PEASEC research group) and Fraunhofer IGD—contributes to understanding the human and organizational factors influencing privacy compliance in software engineering. Their collective work aims to bridge the gap between privacy policies and actual software behavior by focusing on the critical role of developers.

Reviews

Dr. Zero (Offensive Security Researcher) — PASS

You needed a multi-author academic paper to figure out that corporate lawyers care about liability and developers don't have time to write compliance tests? This is purely academic busywork stating the bleeding obvious. There is zero actionable signal here for anyone who has ever actually worked in a development environment.

Heather Calloway (CISO) — MUST SEE

This research confirms what every CISO already suspects: the gap between our published privacy policies and our actual code is a massive, unmanaged risk. Developers know when they are building non-compliant data flows, but they lack the tooling, budget, and governance to fix it. If your general counsel is writing policies that your engineering team isn't testing against, you are actively drafting your own regulatory fines.

→ Top-rated talks at Privacy Enhancing Technologies Symposium (PETS) 2026

All talks from Privacy Enhancing Technologies Symposium (PETS) 2026