Data leaks in internal systems: where they start

Data leaks in internal systems: the common paths data takes out without passing through the screens, and a simple test your team can run for each.

01 Link without login Report or attachment opens from the URL Private window 02 Open API Answers without an access token Call with no token 03 Broad permission Change the ID in the URL, see other data Regular user 04 Exposed file Backup or copy in unrestricted storage Direct link 05 Third parties Integration with more access than needed Own credential Test list: closed, open or we don't know Every open item becomes a task with an owner and a deadline Data leaves without passing through the screens, and the login page never notices Data leaks

Quick answer

In internal systems, leaks usually start on paths nobody checks: a report link that opens without login, an API that answers without authentication, a role with overly broad permissions, a backup in open storage, or an integration with more access than it needed. Each path has a simple test the team can run in a few minutes.

What you will find

  • Why a leak in an internal system can go unnoticed for months
  • The five most common paths data takes out without passing through the screens
  • A list of simple tests your team can use to check each path in your own system
  • How to run the tests in one afternoon, with an owner and a record of the results
  • What changes when the system belongs to a vendor or shares data with third parties
On this page
  1. What is a data leak in an internal system?
  2. Why does a leak go unnoticed for months?
  3. How does data get out without passing through the screens?
  4. How do you test each path in your system?
  5. How do you organize the tests with your team?
  6. What if the system belongs to a vendor or is integrated with third parties?
  7. When is this list not enough?
  8. Frequently asked questions

The IT manager at an industrial services company reads that a competitor in the same sector had employee and customer data exposed. From what was made public, there was no sophisticated attack. A report in the competitor's internal system could be opened through a link that never asked for a password, and that link had been forwarded by email for months. The next morning, a simple question lands on the manager's desk: does our system have a door like that?

This article shows how data usually gets out of an internal system in practice and gives you a list of tests your team can use to check each path. The focus is on how the leak actually happens. What shows up on screens, in reports and in logs, from the point of view of Brazil's General Data Protection Law (LGPD), is covered in the article on LGPD in internal systems. Here the subject is data that leaves the system without passing through those screens.

What is a data leak in an internal system?

A data leak in an internal system happens when information stored by the system becomes available to someone who should not have access to it. That someone could be a person outside the company, a vendor, an employee from another business unit or a bot crawling the internet. There isn't always a break-in. Often the data was simply reachable and someone found it.

OWASP, a nonprofit foundation that publishes open software security references, keeps broken access control in first place on its 2025 Top 10. According to the document, 100% of the applications tested in the project's dataset had some form of this flaw. The category covers exactly the paths in this article: a page that opens without login, a user who sees someone else's record by changing a number in the address, an API with no access control, and backup files left inside the server's public folder.

Internal systems carry more risk for a simple reason. The system was built to be used inside the company, by people everyone knows, and many decisions were made on that assumption. Over time it gained internet access, a mobile app, an ERP integration and a link so a vendor could check orders. The assumption changed, and the old decisions stayed in place.

Why does a leak go unnoticed for months?

A leak goes unnoticed because, on most paths, unauthorized access looks like normal access. Someone who opens a link without logging in or calls an open API triggers no alarm. The system hands over the information as it would to any user, and the event log, when there is one, shows an ordinary request.

Three factors usually add up:

  1. The system was built in layers, by different people, over several years. Whoever created the report share link has left the company, and nobody knows the link exists.
  2. The tests the team runs are functional tests. They check that the report opens for the people who need it, and almost never check that it stays closed to the people who don't.
  3. Part of the path sits outside the system: the backup in cloud storage, the database copy in the test environment, the credential the BI vendor received three years ago.

Verizon's annual incident report, the 2026 DBIR, backs up the third point. In this year's edition, breaches involving a third party reached 48% of the total, a 60% increase over the previous edition. The same report lists employees' use of unapproved AI tools as the third most common activity among non-malicious leaks. The data leaves through the integration or through a copy someone made, while the system's front door stays locked.

Hospitals, ports and manufacturers keep personal and operational data in internal systems: staff schedules, contractor documents, patient or service history, shipping schedules. When these systems grow without review, the exposure can last for months until someone from outside reports it.

How does data get out without passing through the screens?

Data gets out through five main paths, and all of them have one thing in common: they skip the login screen the team thinks of as the system's protection. The table sums up each one.

PathHow it happensSign that it may exist
Link without loginA report, attachment or detail screen opens straight from its address, with no authenticationThe system has a "share by link" button or emails reports with a link
Open APIThe mobile app or web screen pulls data from an API that answers any requestThere is a mobile app, integration or dashboard that consumes data from the system
Overly broad permissionA logged-in user sees data from another unit or another customer by changing a number in the addressThe system's addresses show sequential numbers, such as /order/1532
Exposed fileA backup, export or attachment sits in unrestricted storage, or in a test environment with real dataNobody can say where the backup is or whether staging uses a copy of production
Third-party integrationA vendor or external system received a credential with access to everything, beyond what it neededThere are old integrations, from contracts that have ended or that nobody reviews

Overly broad permissions deserve special attention because they fool even the people who test. The user logged in, so the login screen worked. The problem is one step later: the system checks that the person is logged in, but it doesn't check that the specific record belongs to them. OWASP ranks this flaw first on its API Security Top 10 and describes the mechanism like this: the attacker changes the object identifier in the request and the server returns another user's data. According to the document, the flaw is extremely common and easy to detect.

Open APIs tend to appear when the system gets a mobile app. The web version enforces permission rules on the screen, and the app came later, using an API someone published in a hurry. If the rule for who sees what lives only on the screen, anyone who calls the API directly skips the rule.

How do you test each path in your system?

The list below gives, for each path, tests your technical team can run without special tools. Some can be done by the manager, with a regular user account and a private browser window.

Data leak paths in internal systems and the test for each one

Ready to use · 16 items

Run the tests with a regular user account and, where noted, from a computer outside the company network. Record the result of each item as "closed", "open" or "we don't know". Any open or unanswered item becomes a task with an owner and a deadline. The tests exist to find the flaw: stop as soon as you confirm the data shows up, and do not go further.

Links and pages that skip the login

APIs that answer without authentication

Overly broad permissions

Files, backups and copies in open locations

Third-party integrations

To adapt the list, start with the path that best fits the system's history. If it got a mobile app in recent years, start with the APIs. If it shares data with many vendors, start with the integrations. If nobody has ever been able to say where the backup is, start there.

If any item comes back "open", treat it as a priority and fix it before moving on. A link without login that exposes personal data calls for action the same day: disable the link or the feature first, and only then look into how long it was reachable.

How do you organize the tests with your team?

The tests fit into one afternoon if you prepare ahead. A plan that works:

  1. Set up two test users in the production environment, one with a regular role and another with a role from a different unit or customer. The technical team creates both and removes them at the end.
  2. Ask the team in advance for three lists: the API endpoints, the active integrations with each one's credential, and the locations of backups and exports.
  3. Go through the test list in a meeting, with the technical lead running the tests and the manager taking notes. Each item gets "closed", "open" or "we don't know".
  4. For each open or unanswered item, assign an owner and a deadline. Items that expose personal data go to the top.
  5. Keep the record with the date and result. You will use it to repeat the tests after the fixes and to show what was checked if anyone asks.

The record in step 5 is usually what's missing when an incident happens. Without it, nobody can say whether the path was open from the start or was opened by a recent change.

In the systems we build, the rule for who sees what lives on the server as well as on the screen, precisely to close off overly broad permissions and open APIs. In the access control system for an industrial complex, for example, each company operating on site sees only its own records, and the history keeps track of who approved or denied each access request.

What if the system belongs to a vendor or is integrated with third parties?

If the system belongs to a vendor, the list becomes a set of questions for them. Ask them to show you, in a meeting, the link without login test, the record number test and where the backup is stored. A serious vendor can do this. If the answer is vague or takes weeks, record it as a risk to address when the contract comes up for renewal.

For integrations, the key point is the scope of the credential. Each external system should have its own credential, with access only to what it needs, that can be revoked without affecting the others. When every integration uses the same administrator account, a leak at the BI vendor exposes the whole database, and changing the password breaks every integration at once. That's why the change usually gets postponed, and the old credential keeps working.

People are a path too. An employee who exports a spreadsheet to paste into an outside AI tool takes data out of the system without any technical test noticing. The answer involves limiting who can export what and agreeing with each department on which tools are approved. If the system itself was put together with an AI tool by someone in the business, the guide to reviewing AI-built systems covers the specific risks in that case.

When is this list not enough?

The list finds the most common paths, but it has limits. It doesn't replace a penetration test by a specialist, it doesn't review the code line by line, and it doesn't look for flaws in outdated libraries. It also doesn't cover how to respond to an incident that has already been confirmed.

If a test shows that personal data was exposed, bring in the company's Data Protection Officer and legal team before making any other decision. The LGPD requires certain incidents to be reported to the ANPD, Brazil's national data protection authority, and the authority keeps a page with guidance on what to report and by when. Companies outside Brazil should check the equivalent rules in their own jurisdiction. That assessment belongs to the person responsible at the company, with legal support.

Older systems often have several paths open at the same time, and sometimes the fix requires changing how the system handles permissions. In those cases, modernizing in stages tends to cost less than patching each spot. For a new system, the security checklist before production keeps these paths from being opened in the first place.

boosting.tech, a custom software company, offers a fixed-scope security assessment for internal systems. It looks for these paths in your system and delivers a list of what to close first. The first conversation is free and can be scheduled through the contact page. For ongoing fixes after that, see the support and modernization service.

Frequently asked questions about data leaks in internal systems

How can you tell if your company's system has already had a leak?

You can't always know for sure. The first step is to check whether the paths on the list are open today. If one is, look at the server and API access logs to see how long there have been requests from outside or with no identified user. When there are no logs, the company can neither prove nor rule out a leak, and that alone shows what needs to be fixed.

Can a system that only runs on the internal network leak data?

Yes. Staying on the internal network reduces exposure to outsiders, but it doesn't solve overly broad permissions, integrations with too much access or backups in open locations. An employee in one unit may see another unit's data, and a vendor with VPN access can reach the system. On top of that, many systems that started out internal later gained a mobile app or outside access that nobody documented.

Who should run the tests on the list?

Ideally, the technical lead runs the tests while the department manager follows along and takes notes. The technical lead knows the API endpoints and where the backups are. The manager knows which data is sensitive and who should see what. Tests like opening a link in a private window or changing the number in the address can be done by the manager. For vendor systems, ask the vendor to run the tests in front of you.

Does changing the password fix things after you find an open path?

It depends on the path. If the problem is a link without login or an API without authentication, changing the password does nothing, because those paths don't use a password. The system itself has to be fixed. If the problem is an integration credential with too much access, or one that leaked, then you do need to revoke it and create a new one with a narrower scope. Either way, record what you found and when it was fixed.

How often should you repeat the tests?

Repeat them whenever the system gets a sharing feature, an app, a new integration or a new environment, because those are the changes that open these paths. Beyond that, a review every six months is usually enough for stable internal systems. The review of integrations and administrator accounts can go on the same calendar as the access review you already do with HR.

System support and modernization

We take over existing systems and modernize them in parts, without stopping the operation.

Talk on WhatsApp See the service

Founder and developer, boosting.tech

Founded boosting.tech and has built custom software for more than 10 years. Writes from the systems the company builds and maintains, the oldest of them in continuous development since 2019.

Let us understand your process

The first conversation has no cost. You leave knowing where to start, even if you decide not to go ahead with us.

Example: today we track permits to work on paper and spreadsheets.