Foundational Integrates with Cyera: Security Findings, Traced to the Code That Wrote Them


If your team runs Foundational and Cyera, your AI and data governance capabilities have now become a lot more powerful.
Starting today, Foundational integrates with Cyera. Cyera's issues and data classes now land directly on the Foundational Data Graph, matched down to the column. For joint customers, that means two things: a) Every column in your lineage can carry its sensitivity, and b) Every Cyera finding arrives with its root cause and its blast radius already attached.
We built this because of a pattern we kept seeing in banks, insurers, and other regulated enterprises. Security finds sensitive data somewhere it shouldn't be. Then the slow part starts. Which job wrote this column? Who owns that code? What reads this table today? When did the problem start, and how? In many cases, the answers are found by looking at git, which is exactly our expertise.
What Foundational customers get
- Sensitivity on your lineage. Matched tables, columns, and files carry Cyera data classes and scan status in the entity panel, in search, and across lineage views. You can follow classified data as it moves through the estate.
- A root cause for every finding. Each Cyera finding shows the source system, job, code file, and commit that wrote the data.
- An owner, automatically. Findings become Foundational issues in a Data security category, with the code owner attached. Your existing workflow rules route them to the owning team in Slack or the issues dashboard.
- The blast radius. See every table, BI report, model, and AI agent that reads the affected columns, and what a fix will touch.
- A flag when code drifts. If the code that writes an asset changed after Cyera's last scan, Foundational shows it.
- Agents that know what's sensitive. The same context is available in Foundational IQ, the Foundational API, and our MCP server. An AI agent, or a coding agent about to change a table, can check what the data is, where it flows, and who owns it before it acts.
- Verdicts you can trust. Foundational marks an asset as not sensitive only when Cyera scans it and finds no data classes. A pending scan, an empty response, or an unscanned object gets no verdict.
What Cyera customers get
Already running Cyera? Foundational takes each finding from detection to a fix, with the context your security team would otherwise chase down by hand.
- Fix it at the source. Every Cyera finding traces back to the source system, job, code file, and commit that wrote the sensitive data, so remediation goes after the transformation that caused it.
- See the full blast radius. Know every table, BI report, model, and AI agent that reads an exposed column before you decide how to respond.
- Reach every layer that writes data. Foundational parses application code, pipelines and mainframe programs in COBOL, PL/I, Java, C# and more, so a finding on data produced deep in an established system arrives with the same context.
- Know when a result needs a second look. If the code that writes a scanned asset changes after Cyera's last scan, Foundational flags it, so you know which results to revisit.
- Show auditors the full path. Cyera's classification plus Foundational's lineage gives you a source-to-report record for GDPR, BCBS 239 and DORA reviews.
- Bring data context to your AI agents. Through Foundational's API and MCP server, agents can check whether data is sensitive, where it flows and who owns it before they act.
- Add it in minutes. Read-only Cyera API credentials, no access to your data, and SaaS, on-premises or air-gapped deployment.
How it works

Setup takes a few clicks: Create Cyera API client credentials, then add them to the Cyera card under DSPM on the Foundational integrations page. Foundational reads from the Cyera API and changes nothing in Cyera.
From there, Foundational pulls findings, data classes, and scan status on a schedule. It matches each Cyera datastore, table, column, and file to a node in the graph by platform, host, database, schema, and object identifiers. Lineage does the rest. Because Foundational builds it by analyzing source code in SQL, Python, PySpark, Java, Scala, C#, C++, COBOL, PL/I and Informatica, it reaches the application code, pipelines, and mainframe programs where sensitive data actually gets written.
Foundational never reads the underlying data, and the integration runs in every deployment model we support: SaaS, on-premises, and air-gapped.
What it looks like in practice
Say a global bank's Cyera deployment flags national ID numbers in an analytics table that should only hold masked values.
In Foundational, the finding opens with the Spark job, the commit that changed its masking step, and the job's code owner. Downstream lineage shows two risk reports and an internal AI assistant reading the table. The issue goes straight to the owning team. They fix the transformation; Foundational's pull request impact analysis shows the downstream effect before the fix merges, and the next Cyera scan confirms the result.
No hunting for an owner. No guessing at the blast radius. And a source-to-report record the bank can bring to its next GDPR or BCBS 239 review.
Why this matters to us
For most of our customers, data security and data governance grew up as separate programs, with separate tools and separate owners. AI is pulling them together. An agent that reads across warehouses, applications, and SaaS tools raises both questions at once: what is this data, and where did it come from?

Regulators ask both questions too. BCBS 239 expects complete, end-to-end lineage for risk data. GDPR requires records of processing and accurate data maps. DORA asks for ICT asset inventories and dependency mapping. The EU AI Act requires data governance and logging for high-risk AI systems. Compliance stays with each organization, and this integration helps teams compile the evidence those reviews require.
That's why we see the Cyera integration as a core part of Foundational's future. We're building one graph of code, data, and applications that people and agents can rely on. Adding Cyera's view of sensitive data to that graph makes it a lot more complete.
Get started
Already a Foundational customer? Connect Cyera from the integrations page and follow the setup guide. Using Cyera and new to Foundational? Book a demo, and we'll show your Cyera findings traced to source code in your own environment.
<script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.8.0/gsap.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.8.0/ScrollTrigger.min.js"></script>
<script>
// © Code by T.RICKS, https://www.timothyricks.com/
// Copyright 2021, T.RICKS, All rights reserved.
// You have the license to use this code in your projects but not to redistribute it to others
gsap.registerPlugin(ScrollTrigger);
let horizontalItem = $(".horizontal-item");
let horizontalSection = $(".horizontal-section");
let moveDistance;
function calculateScroll() {
// Desktop
let itemsInView = 3;
let scrollSpeed = 1.2; if (window.matchMedia("(max-width: 479px)").matches) {
// Mobile Portrait
itemsInView = 1;
scrollSpeed = 1.2;
} else if (window.matchMedia("(max-width: 767px)").matches) {
// Mobile Landscape
itemsInView = 1;
scrollSpeed = 1.2;
} else if (window.matchMedia("(max-width: 991px)").matches) {
// Tablet
itemsInView = 2;
scrollSpeed = 1.2;
}
let moveAmount = horizontalItem.length - itemsInView;
let minHeight =
scrollSpeed * horizontalItem.outerWidth() * horizontalItem.length;
if (moveAmount <= 0) {
moveAmount = 0;
minHeight = 0;
// horizontalSection.css('height', '100vh');
} else {
horizontalSection.css("height", "200vh");
}
moveDistance = horizontalItem.outerWidth() * moveAmount;
horizontalSection.css("min-height", minHeight + "px");
}
calculateScroll();
window.onresize = function () {
calculateScroll();
};let tl = gsap.timeline({
scrollTrigger: {
trigger: ".horizontal-trigger",
// trigger element - viewport
start: "top top",
end: "bottom top",
invalidateOnRefresh: true,
scrub: 1
}
});
tl.to(".horizontal-section .list", {
x: () => -moveDistance,
duration: 1
});
</script>
See your Cyera findings traced to source code
Book a demo and we'll show Cyera findings mapped to code-level lineage in your own environment.
See your Cyera findings traced to source code
Book a demo and we'll show Cyera findings mapped to code-level lineage in your own environment.
See your Cyera findings traced to source code
Book a demo and we'll show Cyera findings mapped to code-level lineage in your own environment.





