Software Procurement · 9 min read · November 12, 2026

Data Protection in Custom Software: What to Demand Before You Sign

Data protection in custom software is not a layer you add at the end: it is a set of decisions made during the project, such as which data to collect, who can access what, how long to keep it, and how to delete it. If you are hiring a custom-built system, you should require your software house to cover these decisions in the scope, in the contract, and at delivery. In this article, we list the principles that LGPD, GDPR, and similar laws have in common, what each one means in development practice, and what to ask for in writing. One caveat: this is an engineering perspective, not legal advice. How the law applies to your case is a matter for your legal team or your data protection officer.

This article is part of the guide: Custom Software Development Cost: What Really Drives the Price

Laptop with a security padlock on the screen on a work desk
Photo by Sasun Bughdaryan on Unsplash

Data protection in custom software: what the laws have in common

Each country writes its own law, but the core repeats. LGPD for systems in Brazil, GDPR in Europe, and the rules of other countries start from very similar ideas: collect what is necessary, have a justification for every use, respect what people can request about their own data, and protect all of it with reasonable technical measures.

For anyone commissioning software, this is good news. If the system is built on these principles, it tends to meet several laws at once, and adapting it to a new market takes less work. The opposite is also true: a system that ignores the principles in one country rarely meets them in another.

The principles that weigh most on the code are the following:

  • Minimization: collect and keep only what is necessary for the purpose.
  • Legal basis and consent: know why each piece of data is processed and be able to prove it.
  • Data subject rights: access, correction, portability, deletion, and objection.
  • Access logging: know who viewed or changed what, and when.
  • Retention and deletion: a defined retention period and a routine that actually deletes.
  • Security: encryption, access control, and separate environments.
  • Incidents and third parties: a response plan and clear responsibility across the supplier chain.

Minimization and legal basis: decide before you design the screen

The most common mistake we see is the form that asks for everything because it "might be useful later." Date of birth, ID document, full address, alternate phone number. Every extra field is another piece of data that has to be protected, retained for a set period, exported if the data subject asks, and deleted when the time comes.

That is why the conversation about data should happen during requirements gathering. For each field, ask: what is it for, which business process breaks if it does not exist, and what legal basis supports it. If no one has an answer, the field goes.

Consent is only one of the possible legal bases. Data needed to perform a contract or meet a legal obligation, for example, normally does not depend on it. Your legal team decides which basis applies; the development team's job is to record that decision by data type. When consent is the basis, the system needs to store when it was given, for which version of the text, and how the person can withdraw it, as easily as they gave it.

Data subject rights, retention, and deletion: what the system needs to do

Data subject rights only work if the system knows where each person's data is. It sounds obvious, but in systems with years of use, the same customer shows up in the main table, in exported reports, in logs, in attachments, and in backups. When a deletion request arrives, nobody knows where to start.

The way to avoid this is to design these routines from the start. Ask that the delivery include, at a minimum, a way to locate all of a person's data, export it in a readable format, and delete or anonymize it consistently.

Retention follows the same logic. Define a retention period for each data type and an automated routine that enforces it. Watch out for one technical detail: truly deleting is different from marking as inactive. Many systems use soft deletion, where the record stays in the database with a deleted flag. That works for operational history, but it does not replace actual elimination when the law or the retention period requires it. Agree with the software house on what is anonymized, what is removed, and what must be kept due to a legal obligation, and on how backups factor into all this.

Encryption, access control, and access logging

Data security in software comes down to three questions: is the data protected while in transit, is it protected while stored, and can only the people who should see it actually see it?

In practice, this means traffic that is always encrypted (HTTPS and secure connections between services), sensitive data encrypted at rest, and passwords stored with algorithms designed for that purpose, never in plain text. Encryption keys should not live inside the code or in the same place as the data.

Access control is where most systems fail out of laziness. The principle is least privilege: each role sees only what it needs to do its job. A support agent does not need to export the entire database. Ask whether the system has configurable permission roles, whether administrative access requires two-step authentication, and how accounts are revoked for people who have left the company.

Finally, access logging. A useful log answers who viewed, changed, or exported a piece of personal data, when, and from where. It must be protected against tampering and contain as little personal data as possible. A log that records the entire body of requests, passwords and documents included, becomes a new problem instead of a solution.

Test environments without real data

Copying the production database to a developer's machine "just to test" is a common practice and one of the easiest risks to eliminate. The test environment usually has less protection, more people with access, and forgotten backups. Real data there is a leak waiting to happen.

The alternative is to use fictitious data generated by script, or real data irreversibly anonymized, in which names, documents, and contact details are replaced while keeping the structure the tests need. In rare cases, such as reproducing an error that only occurs with specific data, access to production should be occasional, authorized, and logged.

When hiring, ask the software house to describe in writing how it separates development, staging, and production, and who has access to each. If the answer is vague, that is a warning sign. The same applies to migrating from an old system, where real data has to go through rehearsals before cutover; the rehearsal should take place in a controlled environment and with the same care as production.

Incidents and subcontractors: what happens when something goes wrong

No system is immune. What separates a scare from a crisis is knowing what to do in the first hours. Most data protection laws require reporting relevant incidents to the authority and, sometimes, to data subjects, within deadlines that vary by country. Your legal team defines what to report and when; the software house needs to be able to provide the technical information for it.

That requires the ability to detect and investigate: preserved access logs, alerts for abnormal behavior, and a named point person on the supplier's side. Agree in the contract on how quickly the software house will notify you after discovering an incident and what information it will provide: which data, how many people, the probable cause, and what has already been contained.

The chain of third parties deserves its own attention. Cloud hosting, email delivery, payments, monitoring tools: every service that touches personal data is a subcontractor. Ask for the list, the country where the data is stored, and assurance that each one is subject to obligations equivalent to yours. Changes to the list should be communicated beforehand, not afterward.

What to require from the software house in the contract and at delivery

Much of what we described above only becomes reality if it is in writing. When evaluating proposals, use this list as a roadmap. It complements the questions we suggest in how to choose a software house.

In the contract, require:

  • Defined roles: who is the data controller (normally you) and who acts as the processor (the software house), with processing limited to your instructions.
  • Formal confidentiality for all professionals with access to the data.
  • A list of subcontractors, with advance notice of changes.
  • Deadline and content for incident notification.
  • What happens to the data at the end of the contract: return in a usable format and verified deletion from the supplier's databases.
  • The right to audit or, at a minimum, to receive evidence of security measures.
  • At delivery, verify that these exist: documentation of which data the system processes and why; working access roles and access logging; retention and deletion routines; encryption in transit and at rest; backups with a retention policy; and test environments without real data.
  • Test evidence: ask for a demonstration of exporting and deleting the data of a fictitious data subject, and of access being denied to a role without permission.

Legacy systems: where the risk tends to live

Old systems accumulate too much data, weak passwords, shared logins, and outdated libraries. That does not mean they have to be thrown away, but compliance must be part of the plan. At SKAD, we handle legacy system modernization incrementally: we first address the highest-risk points, such as access, logging, and unnecessary data, without stopping operations.

It is also worth remembering that data protection does not end at delivery. Dependencies become outdated, vulnerabilities appear, and people join and leave the company. See what should be covered in software maintenance and how to hire it, including security updates and periodic access reviews.

How much this costs depends on the size of the system, the amount of sensitive data, and what already exists. For a reference on how these items fit into the budget, see the guide to how much custom software costs.

Frequently asked questions

Do LGPD and GDPR require the same things from software?

They are not identical, but they share principles such as minimization, legal basis, data subject rights, and security. Building the system on these principles covers a large part of both laws; local details should be validated by your legal team.

Who is responsible for data protection: me or the software house?

In general, the company that owns the system is the controller and is accountable for decisions about the data. The software house acts as the processor and must follow your instructions and apply security measures. The contract needs to make this division explicit.

Can I use real data to test the system?

Ideally, no. Prefer fictitious or irreversibly anonymized data. If it is unavoidable, limit access, log its use, and delete it afterward.

What should happen to the data when the contract with the software house ends?

Require return in a usable format and verified deletion from the supplier's databases, while respecting any legal retention obligations. This should be in the contract from the start.

Is encryption enough to be compliant?

No. Encryption is an important security measure, but the laws also require a legal basis, respect for data subject rights, defined retention, and incident management. Security without those other points covers only part of the problem.

Conclusion

Before signing with any supplier, turn the list from the previous section into questions and ask for answers in writing. A team that already works with minimization, role-based access, and test environments without real data will answer quickly and plainly; if there is hesitation, it is worth investigating further. Take the results to your legal team to validate the legal bases and retention periods. A good way to test this in practice, before committing to a larger contract, is to start with a free prototype of your app: you see how the team thinks through the flow, which data it asks for and why, and you already have concrete material for the conversation about data protection.

Keep reading