featured articles

In the age of AI-driven development, architecture matters more than ever. Prompts don't change individual lines of code, they change how systems are composed, connected, and allowed to interact. But to change an architecture, you first need to understand what already exists.

In most organizations, that understanding lives in architecture diagrams across tools like Lucid, Draw.io, Miro, and other diagramming platforms.

We benchmarked leading AI models on their ability to understand these diagrams at scale and found that while general-purpose models work on small systems, they break down quickly as complexity grows. Prime maintained accurate system-level understanding even on large, complex architectures, highlighting the difference between describing diagrams and reasoning about real systems.

Why does architecture understanding matter for AI-driven development?

As software systems grow more distributed, interconnected, and automated, architecture has become the primary unit of change. Products are no longer shaped line by line, but by decisions about composition, interaction, and boundaries.

The core decisions that manifest in architecture include:

• How services are composed
• Where trust and responsibility boundaries exist
• Which components are allowed to communicate by default
• How data flows across the system

Once AI enters the development loop, many of these decisions stop being explicit. Choices about service boundaries, dependencies, and integration patterns are increasingly embedded inside prompts and generated artifacts, rather than surfaced through formal design discussions. In practice, the most durable record of those decisions lives in architecture diagrams across tools like Lucid, Draw.io, Miro, PowerPoint, and similar systems-diagrams that reflect how teams actually reason about structure, dependencies, and boundaries.

That leads to a very practical question: If AI systems are going to contribute to building modern software, can they reliably understand the architectures organizations already use to reason about change?

Where architecture diagram understanding breaks down

In practice, this is where teams start to run into problems.

Through our work at Prime with Security Architecture and Product Security teams, we repeatedly saw the same pattern. Uploading an architecture diagram into an LLM often appears to work at first. The model describes the system, names key components, and even infers a few flows.

But as diagrams grow in size or complexity, exactly where real production systems live, the output becomes unreliable:

• Components are missed or merged
• Relationships are dropped or misrepresented
• Trust boundaries disappear
• Critical structure is confidently simplified away

This wasn't a prompt issue, and it wasn't tied to any single model. We saw the same failure modes across teams, tools, and use cases. What broke wasn't the explanation, it was the model's ability to preserve system structure as complexity increased.

At that point, the question stopped being "can LLMs describe diagrams?" and became something more fundamental.

So we decided to measure it.

The experiment: How well can AI models understand architecture diagrams?

We designed a benchmark to test how well different AI systems can understand and extract structure from architecture diagrams.

Systems tested

We ran the experiment across multiple leading, state-of-the-art models, alongside improved methodologies we developed at Prime, using the same inputs and prompts.

What we measured

Two core capabilities:

Node accuracy – How accurately the model identifies and classifies components in the diagram

Edge accuracy – How accurately the model identifies relationships, flows, and connections between components

Edges are particularly important from a security perspective, since they represent data flows, trust boundaries, and potential attack paths.

Methodology

• We used architecture diagrams at increasing levels of complexity, ranging from small diagrams (~15 nodes) to large diagrams (~150 nodes and ~160 edges)
• Each test was run three times per model, averaging the results
• Inputs were high-resolution PNG images generated using draw.io
• Prompts were kept consistent across runs to eliminate prompt bias
• The same diagrams and prompts were used for all models

Can AI models accurately extract components from architecture diagrams?

Node accuracy results

All models performed well on small diagrams. The problems appeared quickly as scale increased:

• Once diagrams exceeded roughly 30-40 nodes, general-purpose models began to degrade rapidly
• Accuracy collapsed entirely for some models by ~50 nodes
• Prime maintained ~95–100% accuracy even at 150+ nodes

The degradation wasn't gradual decline, it was structural collapse. Models that correctly identified 95% of components in a 20-node diagram would miss or merge half the components in a 60-node system.

Can AI models accurately identify relationships in complex architectures?

Edge accuracy results

Edge extraction proved significantly harder for every system, and this is where the real problem lives.

• General-purpose models showed steep degradation as edge count increased
• Some dropped to near-zero accuracy well before 100 edges
• Prime stabilized at consistent accuracy even at the highest complexity tested

This distinction matters: identifying components is useful, but understanding how those components interact is where security insight actually comes from. A model that can list every service in your architecture but cannot reliably map which services communicate, where data flows, or which boundaries matter is fundamentally unable to support threat modeling or design review at scale.

The gap between "can describe a diagram" and "can model a system" becomes obvious once relationships enter the picture.

What causes AI models to fail at architecture diagram understanding?

This experiment highlights a fundamental difference in how AI systems reason about architecture.

General-purpose LLMs treat diagrams primarily as visual artifacts. They interpret, summarize, and compress what they see in a single pass. As complexity increases, they lose global consistency: entities blur together, long-range relationships drop out, and structural fidelity gives way to approximation.

This isn't a limitation of model intelligence, it's a structural constraint of the approach. Vision-language models are optimized to describe images, not to extract formal representations of systems. When you ask them to process a 150-node architecture diagram, they're doing visual interpretation at every step. There's no mechanism to maintain global consistency as local complexity increases.

Rather than processing a diagram in a single pass, Prime uses a multi-stage extraction pipeline that first builds a structured representation of components and containers, then separately resolves relationships and flows. This allows the system to maintain global consistency even as local complexity increases.

In short: most models are diagram readers. Prime is a system modeler.

Why accurate architecture understanding matters for threat modeling

This distinction matters because architecture understanding is not an academic exercise.

Teams increasingly need AI systems that can reason about architectures before code exists, across hundreds of concurrent initiatives, and without losing consistency as development velocity increases. If a system cannot preserve architectural structure beyond small diagrams, it cannot reliably support design-stage reasoning at scale.

Consider what breaks when architecture understanding fails:

• Threat models miss critical data flows because the model dropped edges
• Security reviews produce inconsistent guidance on similar architectures
• Risk assessments fail to account for trust boundaries that weren't extracted
• Teams lose confidence in AI-assisted analysis and revert to manual review

At 30% - 50% accuracy, automated threat modeling isn't just less useful, it's actively harmful. Engineers stop trusting security guidance, and security teams spend more time debugging bad outputs than they save from automation.

Conclusion: What it takes to understand architecture at scale

The takeaway is not that LLMs are "bad at diagrams." It's that understanding architecture requires persistent, structured system reasoning, not just visual interpretation.

Most AI systems were built to interpret and describe. Prime was built to model and reason. This experiment makes that difference measurable.

The challenge wasn't incremental, it required rethinking how architectural understanding works. General-purpose models will continue to improve at visual interpretation, but the structural problem remains: treating diagrams as images to describe rather than systems to model means accuracy collapses as complexity grows.

Prime solved this by building extraction pipelines that preserve structure first, then resolve relationships within that structure. The result is consistent accuracy on large, complex diagrams at scales where other approaches break down entirely.

For organizations adopting AI-driven development or trying to scale threat modeling and security design reviews, this matters immediately. The architecture diagrams you already use to reason about systems need to be something AI can reliably understand, not approximately, but structurally. Otherwise, design-stage security remains bottlenecked by manual review, and the gap between development velocity and security coverage continues to widen.

We didn't benchmark architecture diagram understanding to show that Prime is better at reading images. We did it to demonstrate that understanding architecture at scale requires fundamentally different approaches, and that those approaches now exist.

Most security teams are already using AI in threat modeling and security design reviews. They just don't always say it out loud.

It starts informally. A PRD gets pasted into ChatGPT to get oriented before a review. An LLM is asked to summarize a messy Jira epic or extract data flows from a half-written document. A threat model gets sanity-checked after the fact. Not because it's "AI-driven security," but because unstructured design data practically demands it.

Threat modeling has always lived in unstructured inputs: incomplete docs, diagrams that lag reality, tickets that describe intent indirectly. LLMs are simply very good at working with this kind of material. Once teams experience that leverage, they don't go back to doing everything manually.

At that point, the question is no longer whether to use AI in threat modeling. It becomes a much more familiar one: do we build this ourselves, or do we adopt a product?

Why are security teams turning to AI for threat modeling?

The forcing function is velocity.

In many organizations, developers can go from idea to production in a day. New services, integrations, and data flows appear continuously. Meanwhile, security design reviews still assume lead time: intake, scheduling, workshops, follow-ups.

A two-week wait for a threat model is no longer a delay. It's a miss.

Security teams feel this pressure immediately. They can either accept shrinking coverage or find a way to compress design-stage feedback without sacrificing quality. That's where AI enters the picture, intentionally or not.

After speaking with hundreds of teams, a consistent pattern emerges in what works and where things break.

How do security teams start using AI for threat modeling?

The first stage is straightforward and surprisingly effective.

Teams use LLMs for one-off design reviews. Paste in a PRD. Ask for threats. Generate a diagram. Sometimes export it to Mermaid to make iteration easier. For individual reviews, this works well. It's faster than starting from a blank page and often surfaces obvious gaps.

For already-overloaded teams, this alone feels like a breakthrough.

But it doesn't scale in a durable way. Every review is isolated. Context is short-lived. Accuracy depends heavily on who is prompting and what they remember to include. Nothing accumulates.

How do you scale AI-assisted security design reviews?

The next step is almost inevitable.

Someone adds retrieval. Policies get indexed. Maybe internal standards too. A dedicated Claude or ChatGPT project appears. Sometimes a lightweight app gets built using tools like Lovable or n8n. There's an integration with Google Docs to generate threat models in place, or a Slack bot to initiate reviews.

For a while, this feels like the answer. Coverage improves. Intake friction drops. The “scale problem” looks solved. Then reality sets in.

Then reality sets in.

The system doesn't remember past decisions well. Context goes stale. Similar designs get different answers. Engineers lose trust as accuracy hovers around "pretty good," which is not good enough for security guidance. At scale, 50% accuracy is worse than none.

This is where most internal efforts stall.

Why is building AI for threat modeling so difficult?

At this stage, teams rediscover an old lesson: automated threat modeling quality is not about generating text. It's about consistent reasoning grounded in shared memory.

To move past this point, you need:

• An accurate, evolving understanding of the product and its architecture
• Durable memory of past decisions, accepted risks, and exceptions
• The ability to reason over large, messy context without hallucinating

That is hard to build. Harder to maintain. And even harder to explain to engineers when it breaks.

But there is a deeper problem that shows up even when the tooling is solid: visibility still depends on developer behavior.

Most internal systems only see work when someone remembers to ask for a review, uses the right template, or triggers the right workflow. Even with AI assistance, coverage is gated by human compliance. In high-velocity environments, that assumption does not hold. Engineers move quickly, patterns repeat, and small design changes accumulate into material risk without ever crossing a formal review boundary.

This is where many threat modeling programs quietly lose control. Not because reviews are low quality, but because security cannot see what never entered the system.

Should you build or buy AI threat modeling tools?

At that point, the buy-versus-build decision becomes unavoidable.

Building is absolutely an option. With enough time, AI expertise, and dedicated security validation, teams can assemble something that works. But it is expensive, fragile, and non-core. You need engineers who understand LLM behavior, infrastructure to manage context and memory, and security practitioners validating outputs continuously.

Everything is possible, the real question is why invest that effort just to regain visibility that should be table stakes.

The decision is not about whether AI-assisted reviews work. It's about whether rebuilding a bespoke AI security system is the best way to restore visibility across all planned work.

This is also why platforms like Prime exist. Not to "do threat modeling," but to observe design-stage change directly from systems of record like Jira and Confluence, maintain context over time, and surface risk whether or not someone explicitly asked for a review.

Why AI alone doesn't solve the threat modeling scale problem

AI didn’t change what good threat modeling requires. It made it obvious where threat modeling breaks at scale. LLMs can analyze design documents and identify threats, and they’re getting better every month. But the limiting factors aren’t analytical. They’re structural.

First, threat modeling depends on institutional memory. Without durable context about your architecture, past decisions, and accepted risk, guidance stays inconsistent and trust never compounds. Every review starts from scratch.

Second, even perfect threat models don’t help if security can’t see the work. Most risk is introduced through tickets, docs, and design changes that never cross a formal review boundary. If AI only activates when developers remember to ask, coverage collapses.

These aren’t problems you solve with better prompts or more RAG. They require persistent context and proactive visibility into planned work.

That’s the real build-versus-buy question. Not whether AI can help with threat modeling, it can, but whether rebuilding institutional memory and visibility from scratch is the best use of a security team’s finite attention when the real challenge is seeing all the design work happening in the first place.

‍

The Cyber Resilience Act (CRA) is the European Union's most significant product security regulation since GDPR. Formally adopted as Regulation (EU) 2024/2847, the CRA establishes mandatory cybersecurity requirements for all products with digital elements sold in the EU market. Non-compliance carries penalties up to €15 million or 2.5% of global annual turnover, and products that fail conformity assessment lose EU market access entirely.

Unlike previous frameworks focused on organizational security practices, the EU CRA is product-centric. Every software product must prove security throughout its lifecycle to receive CE marking, which signifies that products sold in the EEA (European Economic Area) have been assessed to meet high safety, health, and environmental protection requirements. For security leaders, this regulation formalizes a long-standing principle: security must be considered at the design phase, not retrofitted after implementation. This guide explains what the CRA requires, who it affects, and how to build compliant practices.

Executive Summary

What the EU CRA Regulates

• All products with digital elements: standalone software, IoT devices, firmware, SDKs, and connected hardware
• Applies to any organization selling to EU customers, regardless of headquarters location
• SaaS products with downloadable components (browser extensions, SDKs, agents) are in scope

Key Compliance Dates

• September 2026: Mandatory vulnerability reporting to ENISA begins
• December 2027: Full compliance with all essential requirements

Security by Design is the Essential New Mandate

• The regulation requires documented evidence that security was addressed during “design and development”
• Traditional AppSec tools (SAST, SCA, DAST) operate after code exists and cannot satisfy this requirement
• This design-stage gap is unique to CRA; other regulations (NIS2, DORA, ISO 27001) do not require it

What Organizations Must Do

• Inventory and classify all products by CRA risk tier
• Implement design-stage security review with documented evidence
• Establish vulnerability handling and ENISA reporting processes
• Generate SBOMs and technical documentation for conformity assessment

What Is the Cyber Resilience Act (CRA)?

The Cyber Resilience Act is an EU regulation setting mandatory cybersecurity requirements for all products with digital elements sold in the European market. Formally adopted as Regulation (EU) 2024/2847 and entering into force on December 10, 2024, the CRA represents the most far-reaching product security regulation the EU has enacted. It is product-centric, requiring every software product, from standalone applications to embedded firmware to SDK components, to prove security throughout its entire lifecycle, from initial design through end-of-life support.

Why Was the EU Cyber Resilience Act Introduced?

Product security failures have grown too consequential and too widespread for voluntary standards to fix. When connected devices reach hundreds of millions of households and businesses, a single architectural shortcut can cascade into infrastructure-level disruption. As shown by the October 2016 Dyn attack, attackers compromised over 600,000 IoT devices by exploiting factory-made usernames and passwords, leaving services like Twitter, Netflix, GitHub, and others unreachable for hours.

The vulnerability was not a coding error that testing would have caught but a product design decision. Although GDPR covers the handling of personal data and NIS2 covers critical infrastructure network security, neither imposes obligations on the manufacturers whose design choices created the attack surface in the first place. The CRA fills this gap by making secure-by-design a legal requirement at the point of manufacture, documented and auditable before products reach the market.

What Makes the EU CRA Different From Other Regulations?

The CRA differs from NIS2, DORA, and ISO 27001 in one key way: it regulates products, not organizations. While NIS2 requires essential service operators to implement security measures, and ISO 27001 certifies organizational security management systems, the CRA requires each individual product to meet specific security requirements and undergo conformity assessment before receiving CE marking for EU market access.

This product-level focus means compliance cannot be achieved through organizational policies alone. Each product requires documented evidence that security was considered and implemented throughout its development, starting at the design phase.

What are the Key Dates You Should Know?

The CRA follows a phased implementation timeline:

‍

‍

Why the September 2026 Deadline Matters:

While December 2027 is the full compliance deadline, September 2026 introduces mandatory vulnerability reporting. This means organizations need:

• Documented vulnerability handling processes
• Established reporting channels to ENISA
• Systems for detecting actively exploited vulnerabilities
• Evidence of ongoing security monitoring

For companies selling to EU customers, this provides an implementation window to build the practices that form the foundation of CRA compliance, including design-stage security reviews.

Penalties for Non-Compliance

The CRA establishes a tiered penalty structure based on violation severity:
‍

Beyond financial penalties, non-compliance affects:

• CE marking eligibility and EU market access
• Product availability (potential withdrawal or recall requirements)
• Customer confidence in your security practices

Which Organizations Must Comply with the CRA?

The CRA specifically calls out four classifications of software providers:

1. Manufacturers

Organizations that design, build, or brand products bear primary responsibility for CRA compliance.

This includes:

• Software publishers selling to EU customers
• Hardware manufacturers with embedded software
• Companies that white-label or rebrand products
• Organizations that substantially modify existing products

2. Importers

Entities that bring products from outside the EU into the EU market must verify compliance before distribution.

3. Distributors

Entities in the supply chain that make products available.

4. Open Source Considerations

Open source software developed outside commercial activity is generally exempt.

However:

• Commercial products using open source components must ensure those components meet CRA requirements
• Any open source integrated into commercial products becomes the manufacturer's responsibility

Does the CRA apply to companies outside the EU?

Yes. The CRA applies to any entity that places products with digital elements on the EU market, regardless of where that organization is headquartered. Non-EU manufacturers must comply with all essential requirements to receive CE marking and maintain EU market access.

Which Products Are Impacted by the CRA?

The CRA applies to products with digital elements (PDEs), defined as any software or hardware product that connects directly or indirectly to a device or network. The scope is deliberately broad to cover the interconnected nature of modern digital products.

Products in Scope:

• Standalone software applications (desktop, mobile, and web applications with downloadable components)
• Operating systems and firmware
• IoT devices and connected hardware
• Software libraries, SDKs, and APIs distributed as components
• Industrial control systems and OT equipment
• Network equipment (routers, switches, firewalls)
• Consumer electronics with data connectivity

What about SaaS Products?

Pure SaaS offerings, where no software component is downloaded or installed, are generally excluded from the CRA's scope. However, most modern SaaS products include downloadable elements that bring them into scope:

• Browser extensions or plugins
• Desktop or mobile companion apps
• Agent software for integrations
• SDKs provided to customers
• CLI tools or development utilities

If your SaaS product includes any downloadable component, that component falls under CRA requirements, and the security of that component must be proven through design-stage practices.

How does CRA Classify Products and Risk Tiers?

The CRA establishes risk categories with corresponding compliance requirements:

‍

What is required for CRA conformity assessment?

CRA conformity assessment requirements depend on product risk classification. Default (non-critical) products allow self-assessment. Important Class I products can self-assess with harmonized standards or use third-party assessment. Important Class II products require mandatory third-party assessment by notified bodies. Critical products require European cybersecurity certification.

What Are the Essential CRA Security Requirements?

The CRA's essential requirements are defined in Annex I of the regulation and are divided into two categories: security requirements for the product itself, and vulnerability handling requirements for ongoing support.

Part I: Security Requirements for Products

1. Security by Design

Products must be "designed, developed and produced" with appropriate cybersecurity levels based on risk assessment. This requires documented evidence that security was considered during architectural decisions, not added after implementation. The regulation states:

"Products with digital elements shall be designed, developed and produced in such a way that they ensure an appropriate level of cybersecurity based on the risks." (CRA Annex I, Section 1.1)

2. Secure Default Configuration

Products must ship with secure settings by default: least-privilege access, no default credentials, and hardened configurations aligned to intended use. Configurations that require user action to become secure do not meet this requirement.

3. Data Protection

Products must ensure confidentiality, integrity, and availability of data through appropriate mechanisms including encryption, access controls, and data minimization.

4. Resilience and Availability

Products must resist denial-of-service attacks and minimize negative impacts on other network resources.

5. Attack Surface Minimization

Products must minimize external interfaces, disable unnecessary services, and limit the impact of potential compromises through segmentation and containment.

6. Software Bill of Materials (SBOM)

Manufacturers must identify and document all software components, including dependencies, in a machine-readable format — either SPDX or CycloneDX.

Part II: Vulnerability Handling Requirements

• Establish coordinated vulnerability disclosure policies
• Document and remediate vulnerabilities without delay
• Apply effective and regular tests and reviews of product security
• Provide security updates for minimum 5 years or expected product lifetime
• Report actively exploited vulnerabilities to ENISA within 24 hours

Why Security-by-Design Is Core to the CRA Mandate?

The CRA's most consequential requirement is not SBOM generation or vulnerability scanning. It is the mandate for security by design. Article 13 requires manufacturers to "exercise due diligence when integrating components" and ensure products are "designed, developed and produced in accordance with essential requirements." The regulation specifies:

"Manufacturers should therefore ensure that all products with digital elements are designed and developed in accordance with the essential cybersecurity requirements laid down in this Regulation." (CRA (9))

What does Security-by-Design Mean Under the CRA?

Security by design under the CRA means integrating security considerations from the earliest product development phases, during architectural decisions and feature design, not retrofitting security after implementation. The regulation requires documented evidence that security was considered during design, rather than tested only after development.

"Products with digital elements shall be designed, developed and produced in such a way that they ensure an appropriate level of cybersecurity based on the risks." (CRA Annex I)

We continue to see an acceleration in the amount of focus that the design stage is getting from a cybersecurity risk management perspective, driven not solely by this act, but by global cybersecurity organizations and regulators alike.

The Design-Stage Gap

Most organizations have to this point invested substantially in code-level security tools:

• Static Application Security Testing (SAST) finds vulnerabilities in written code
• Software Composition Analysis (SCA) identifies risks in dependencies
• Runtime Application Security Testing (DAST) uncovers vulnerabilities in running applications

These tools serve important purposes, but they operate after code exists.

The CRA asks a different question: What security decisions were made when this feature was designed? 

When a feature moves from specification to implementation, the security-relevant decisions happen early. What data will this access? How will authentication work? What happens if this component is compromised? By the time code exists to scan, these architectural decisions are already made.

Answering the CRA's design-stage question requires security review during the design phase, with documented evidence that can satisfy conformity assessment. This creates a gap for most organizations: they have tooling for code-level security, but not for design-stage security review.

CRA Requirements vs. Traditional Tools and Other Regulations

The CRA creates new compliance obligations that existing tools and regulations do not cover:

‍

These security-by-design requirements create the primary compliance gap organizations must close.

How Does Prime Security Handle CRA Compliance?

Prime Security's Agentic Security Architect closes the design-stage gap by bringing security review to where the CRA requires it: before code is written. Prime identifies security risks in planned work and creates the documented evidence that conformity assessment requires.

Design-Stage Security Review: Prime's Approach

Prime analyzes feature specifications, architectural decisions, and integration plans as they are created, not after they are implemented. 

When a developer writes a Jira ticket describing a new feature, Prime automatically:

1. Identifies security-relevant changes that warrant review
2. Analyzes architectural implications including data flows, authentication requirements, and attack surface changes
3. Generates security recommendations specific to the proposed design
4. Creates documented evidence of security review for CRA compliance

This shifts security review to where the CRA requires it, the design phase, while ensuring consistent coverage across all development activity.

Manual security design reviews can satisfy CRA requirements in theory. In practice, they create an impossible tradeoff. The CRA demands documented security consideration for every feature across every product. Achieving full coverage manually means either hiring a security architect for every development team or slowing releases to a crawl while a small team reviews everything. Most organizations end up with partial coverage and gaps in their conformity documentation.

Prime resolves this tradeoff. By automating design-stage review, organizations achieve the continuous coverage CRA requires without blocking development. Security teams maintain oversight and make final decisions, but the baseline analysis and documentation happens automatically, at the pace of development.

‍

How Prime Helps Companies Meet Specific CRA Requirements?

Security by Design (Annex I, Part I)

The CRA requires that products "be designed, developed and produced in such a way that they ensure an appropriate level of cybersecurity based on the risks." 

Prime ensures that security teams are able appropriately manage the risks of every project by making sure that features are designed securely from the beginning.

Risk Assessment (Statement 37)

The CRA also mandates that “ Manufacturers should ensure that software made available under those conditions is released only following a risk assessment and that it complies to the extent possible with the security requirements relating to the properties of products with digital elements laid down in this Regulation.”

Prime's agent assesses the risk of both new components and existing software based on the rules and regulations set out by each individual company, regardless of size or industry..

Due Diligence on Components (Article 13.5)

The regulation requires manufacturers to "exercise due diligence when integrating components sourced from third parties." 

When development plans include third-party integrations, Prime analyzes the security implications of those integrated design decisions.

Effective and Regular Testing (Annex I, Part II)

The CRA mandates that manufacturers "apply effective and regular tests and reviews of the security of the product." 

Prime fits into your existing workflows between security and engineering,  continuously reviewing development activity.

Technical Documentation (Article 31)

“The technical documentation shall contain all relevant data or details of the means used by the manufacturer to ensure that the product with digital elements and the processes put in place by the manufacturer comply with the essential cybersecurity requirements set out in Annex I.”

Prime creates persistent, auditable records of security decisions, recommendations, and reviews, producing the documentation required for conformity assessment and market surveillance.

How does EU CRA Compare to Other Cybersecurity Regulations?

CRA vs. NIS2

NIS2 (Directive 2022/2555) applies to essential and important entities operating critical infrastructure and requires organizational security measures, incident reporting, and supply chain security. The CRA applies to products regardless of who uses them.

The key differences: 

• NIS2 is entity-focused while CRA is product-focused
• NIS2 requires organizational policies while CRA requires product-level conformity
• NIS2 allows member state variation while CRA is directly applicable EU-wide

Most organizations that need to comply with NIS2 will also need to comply with CRA. A software company providing products to healthcare organizations might need NIS2 compliance as an important entity and CRA compliance for each product sold.

CRA vs. DORA

The Digital Operational Resilience Act (DORA) focuses on financial entities with requirements for ICT risk management, incident reporting, and third-party risk management. 

While DORA regulates organizational resilience, CRA focuses on product security. Financial services companies subject to DORA that also manufacture software products need CRA compliance for those products in addition to DORA compliance for their operations.

CRA vs. ISO 27001

ISO 27001 is a voluntary certification for information security management systems. The CRA is mandatory regulation with legal enforcement. ISO 27001 certification can support CRA compliance by showing mature security practices, but does not substitute for product-level conformity assessment and technical documentation.

FAQ

Does the CRA apply to my company if we're headquartered outside the EU?

Yes. The CRA applies to any organization that places products with digital elements on the EU market, regardless of where the company is based. If you sell software, hardware, or connected products to EU customers, you need to meet CRA requirements and obtain CE marking for those products.

Does the CRA apply to SaaS products?

Pure SaaS offerings with no downloadable components are generally out of scope. However, most SaaS products include elements that bring them in — browser extensions, desktop or mobile apps, agent software, SDKs provided to customers, and CLI tools all fall under CRA requirements. If any component gets installed or downloaded by the user, that component is in scope.

When does my company need to be fully CRA compliant?

Full compliance with all security requirements is due by December 11, 2027. However, mandatory vulnerability reporting to ENISA starts earlier, on September 11, 2026. That earlier deadline means you need documented vulnerability handling processes and reporting channels in place well before the full compliance date.

What is the difference between security by design and traditional AppSec testing?

Traditional AppSec tools — SAST, SCA, and DAST — find vulnerabilities in code that already exists. Security by design means making security decisions during the architectural and feature design phase, before any code is written. The CRA requires documented evidence of the latter; code-level scan reports alone do not satisfy this requirement.

What evidence do I need to pass a CRA conformity assessment?

You need documented proof that security was considered during the design phase of each product, a software bill of materials (SBOM) in a machine-readable format, records of vulnerability handling processes, and technical documentation covering how your product meets the Annex I requirements. For higher-risk product categories, third-party assessment by a notified body is also required.

Getting Started With EU CRA Compliance

The Cyber Resilience Act formalizes what security teams have long advocated: security consideration at the design phase, with documented evidence. The regulation provides clear requirements and a defined timeline to build out security by design best practices. Prime Security closes the design-stage gap by bringing automated security review to the design phase, creating the documented evidence that conformity assessment requires while helping your security architects focus on the strategic decisions that need human judgment.

Ready to Explore Design-Stage Security Review?

Request a Demo to see how Prime Security automates CRA-compliant security design reviews across your development organization.

‍

Get Your Copy:

The Cyber Resilience Act (CRA) Cheatsheet

Download

Today, I’m proud to share that Prime Security has raised a $20 million Series A, led by Scale Venture Partners, with continued support from Foundation Capital and Flybridge Ventures.When Dima, Matan, Danny, and I started Prime almost two years ago, our hypothesis was simple: Security isn’t keeping up with development. Despite endless tools, day-to-day security engineering and architecture work still feels manual, fragmented, and slow. 

We experienced this problem first-hand. Dima’s previous security teams at PayPal were always playing catch-up, while Matan, Danny, and I were delaying releases at Own because of last-minute security requirements. Even two years ago, this was a huge problem.

What we didn’t expect was just how fast development itself would evolve. Everyone became an engineer. AI-powered coding tools exploded. Velocity went through the roof, and the bottleneck for security? It got 5× worse.

We are building Prime to change that.

The AI Security Architect - the Super-Tool Product Security Always Needed

LLMs changed everything. But we didn’t see them as a replacement for security engineers; we saw them as a way to scale their judgment.

From day one, our vision has been to democratize security knowledge across every development team, to make security as embedded and accessible as code review.

That’s what Prime is building: an AI Security Architect - the super-tool security teams have always needed. An agentic system that autonomously reviews design work, identifies risks, and recommends mitigations, before a single line of code is written.

With Prime, security teams can finally cover all development work, not just the 5–10 percent they can manually review today. The result? Teams eliminate review backlogs, accelerate development and save millions in process costs, sometimes tens of millions annually, all while actually improving security outcomes.

It’s not reactive security. It’s preemptive security, where risks are understood and resolved at the design stage, long before they ever become incidents.

We’ve been lucky to work with some incredible early partners - PayPal, Qualtrics, ThoughtSpot, Bumble, Yext, Redis Labs, and many others who believed in our vision early on.

Together, we proved our hypothesis: Product Security teams require tooling that lets them move at the speed of modern development, without compromising on risk visibility.

It’s not about scanning code faster. It’s about thinking about security earlier, when architecture, design, and product decisions are being made.

We started by focusing on the design stage of the product development lifecycle, but that is just the beginning. The challenges of securing modern development don’t end there. They start there.

This Series A funding gives us the resources to go deeper, expand our agentic AI capabilities, and grow our teams across the U.S. and Israel, all with the goal of leading the next era of product security.

We believe security shouldn’t slow you down. It should help you move faster confidently.

That’s what Prime is here to do.

— Michael Nov, Co-Founder & CEO, Prime Security

‍

EVERY SINGLE COMPANY I speak to has adopted or is adopting AI code generation tools. Cursor’s ARR numbers don’t lie. Some companies are pretending they haven’t, calling it “just a pilot” or “a few devs experimenting.” Others are leaning all the way in because they have to. Dev teams are demanding speed. Leadership wants productivity gains. And honestly? These tools are good. Too good to ignore.

But here’s the thing: AI-powered development is already here. It’s loud. It’s fast. And it’s not waiting around for security sign-off. The train has left the station. Security’s still checking the schedule. Google says 25% of their code is now written by AI. If they got there that fast, your org’s not far behind. This isn’t hype. It’s happening.

Let’s not kid ourselves, most developers aren’t generating full-blown apps (yet), especially at mid-sized and larger companies. For now, it’s autocomplete. Maybe a helper function here and there. Seems safe. Harmless.

But we’ve seen this progression before. Autocomplete becomes “generate block.” “Generate block” becomes “why not ship it?” And suddenly, you’ve got AI-assisted infrastructure changes cruising toward production. There’s a Jira ticket. There’s some plan. But no one’s waiting for a security review. The specs are thin, the pace is insane, and the review process? Skipped, sidelined, or rubber-stamped. Just enough structure to ship, nowhere near enough to secure.

And here’s what makes it even scarier: a lot of these changes aren’t greenfield. They’re not new apps. They’re small adjustments to complex, fragile, existing systems. A new flow here. A helper function there. A tiny tweak that seems low-risk, until it breaks something critical or quietly bypasses security controls that were never meant to be touched. And the tools? They simply lack the context to catch it.

We’ve already seen horror stories play out with vibe coders pushing insecure features into production. And we’ve heard of plenty more quietly handled inside enterprises, breaches averted by luck, late-night heroics, or pure chance. This isn’t theoretical. It’s already happening.

So where does that leave Product Security?

Let me be crystal clear: these tools don’t know your threat models. They don’t care about your asset inventory. They sure as hell don’t know your compliance requirements. They don’t know that your legacy billing service is basically a haunted house held together by duct tape, broken dreams, and a regex pattern no one understands.

And now the window between “I had an idea” and “it’s in production” is… what, a couple hours? What used to be design reviews, architecture sessions, a few spicy Slack threads, that’s all gone. It’s now: prompt, pull request, CR, merge. Done.

Manual product security processes? Dead on arrival. If your team still relies on humans to dig through design docs and flag every potential risk before a line of code is written, you’re already underwater. Best case, you slow things down and become that team. Worst case, you get quietly pushed out of the process entirely.

Some companies are trying to solve this by plugging static security rules into their AI dev tools, like that’s going to stop the bleeding. But rules without context don’t make things more secure. They just make the code more bloated. You end up with unnecessary security controls shoved into places they don’t belong, confusing developers and cluttering the codebase. The devs don’t argue. They just ship it and move on. Congrats, you’ve added security theater to the build pipeline. A silent overkill.

But let’s not confuse fixing bugs after the fact with building secure systems in the first place.

None of these tools are going to raise a flag when your architecture is fundamentally broken. They won’t catch it when a new feature opens up a nasty compliance gap. They won’t stop a dev from shipping an unauthenticated admin panel to production because the AI said, “looks good to me.”

They weren’t built for that. And that’s the real problem.

Security teams are staring at a widening gap, and most are still trying to patch it with manual reviews, tribal knowledge, and wishful thinking. But as the pace of development accelerates, absurdly accelerates, those old methods just don’t scale. They’re already cracking under pressure.

The opportunity? Massive. AI-powered development has created an entirely new class of problems, ones the existing security stack was never built to solve. Securing applications  generated at the speed of a prompt requires a new approach, a new mindset, and yes, new tools. Entire categories of security tooling will need to be rebuilt for this world. This isn’t a “feature gap.” It’s a market gap.

So where do we go from here?

Security thinking has to shift upstream. It needs to be seamlessly embedded into planning, not patched onto delivery. It has to evolve from reactive reviews to proactive visibility. It needs to move with the development process, not try to slow it down from the sidelines.

This isn’t about waving red flags after the build pipeline’s already green. This is about being in the room when the feature is defined, before a single prompt is typed into the AI tool.

Because the future isn’t coming. It’s already writing itself.

And if security doesn’t learn to speak that language, to exist inside that flow, it won’t just be left behind. It’ll be ignored completely.

Get a security architect for every project, team, and task, identifying risks, enforcing policies, and accelerating secure development from design.

‍

In part one of this two-part series, we established that PDLC (Product Development Life Cycle) encompasses SDLC (Software Development Life Cycle), and that organizations should adopt both rather than treating them as separate or interchangeable approaches, especially in a world where most “products” are software-based.

This second article dives into the security angle for both PDLC and SDLC. When discussing software security, the focus typically lands on SDLC alone. However, this approach is too narrow for a product-driven landscape. Why? Because SDLC covers only the software portion, while threats today spread far beyond the application code.

Comparing Security Practices of PDLC and SDLC

Here’s the reality: in a world where software companies do everything they can to deliver their products as fast as possible, security can’t just be about the code or the infrastructure. It must be about the product, end to end. That’s where the shift from SDLC-focused security to PDLC-focused security becomes critical. The PDLC isn’t just about building software, it’s about building and managing the entire product, from ideation to decommissioning. And in a modern threat landscape where risks extend far beyond the boundaries of application code, PDLC-focused security is how you keep your product and your business safe.

Let’s take a closer look again at the various stages of PDLC and SDLC but this time, let’s add another layer, security practices for per each framework:

‍

‍

Three crucial insights:

1. In an Secure Product Life Cycle focused approach, security is introduced at a point where significant design and architectural decisions are already made
2. Many existing security processes before stage four (Development & Engineering) are either nonexistent or conducted manually
3. Across stages, there is one common thread - Context. Security Teams need business context in every step, from mapping the regulatory and compliance requirements to understanding when and why a product should be deprecated 

‍

The conclusion - Security should be integrated in every stage

Since organizations developing software-based products operate largely within the PDLC, security must be integrated into every stage, not just during code creation. Success in this model hinges on understanding the broader business context, which acts as the connective tissue across all phases. Tools like Prime Security can help automate and streamline this process, ensuring that security follows the product from concept to retirement.

HIPAA is raising the bar with new cybersecurity rules to protect electronic health information (ePHI). These updates aim to tackle breaches and compliance gaps head-on. For healthcare organizations building software systems, it’s a wake-up call: security needs to start at the design phase.

‍

What’s New?

The proposed HIPAA updates bring significant changes, including:

"Addressable" vs "Required" distinction - The new rules make all security standards mandatory, ensuring that essential protections are implemented consistently across regulated entities

Comprehensive Risk Assessments - Software organizations must inventory their technology assets and map how ePHI flows through systems, offering full visibility into vulnerabilities. These assessments should be conducted regularly, with frequency based on the organization's risk environment, operational changes, and evolving threats. This ensures continuous alignment with compliance and risk management

Mandatory Encryption - Encryption for ePHI is now a baseline requirement, ensuring sensitive health information remains protected in transit and at rest. Software-enabled solutions must include encryption protocols by default to safeguard data, even during potential breaches or unauthorized access attempts

Robust Audit Trails - HIPAA now prioritizes detailed monitoring and logging of ePHI access. Software systems need transparent tracking to identify who accessed data, when, and why. This simplifies regulatory reporting and strengthens accountability

Scalability and Flexibility - The rules remain technology-neutral, enabling software organizations of any size to implement solutions that balance security and operational efficiency. Whether a startup or enterprise, scalable options are critical to staying compliant

The message is clear: retrofitting security won’t suffice. To remain HIPAA-compliant, software systems must integrate security at every stage, starting from design.

‍

Why Security-by-Design Matters

For software organizations building HIPAA-compliant systems, integrating security at the design phase is essential. Here’s why:

Early Risk Mitigation - Design-stage security uncovers risks before they escalate into costly vulnerabilities. This aligns with HIPAA’s proactive focus on risk management and ensures workflows remain seamless

Streamlined Compliance - Embedding security early ensures systems meet HIPAA’s requirements, such as audit trails, encryption, and risk assessments. This reduces the complexity of audits and guarantees long-term compliance

Accelerated Development - Addressing security from the start avoids delays and costly rework, enabling faster releases without compromising quality. HIPAA highlights proactive measures to prevent deployment vulnerabilities

Resilience Against Threats - Healthcare software is a prime cyberattack target. Design-stage security mitigates risks like unauthorized access and breaches, aligning with HIPAA’s call for adaptable systems to combat evolving threats

‍

How Prime Security Fits the Bill

Prime Security helps software-enabled organizations integrate regulatory frameworks like HIPAA directly into their PDLC:

• Continuous Risk Monitoring: Scans planned development work to flag potential HIPAA-related risks, such as gaps in data encryption or insufficient audit trails
• Proactive Mitigation: Provides actionable mitigation plans tailored to address identified risks before development progresses
• Seamless Integration: Embeds compliance and security recommendations directly into developer workflows for easy adoption
• Regulatory Alignment: Simplifies adherence to HIPAA’s requirements for encryption, risk assessments, and ePHI access logging

With Prime, integrating HIPAA compliance into the SDLC becomes seamless, reducing risks and building trust.

‍

The Bigger Picture

HIPAA’s updates are a turning point for healthcare cybersecurity. Organizations adopting security-by-design will:

• Protect patient data efficiently
• Build trust with users and regulators
• Innovate without compromising safety

The future of HIPAA compliance isn’t reactive, it’s preventative. Prime Security is here to help software organizations lead the way.

This blog post is part one of a two-part series exploring the synergy between product and software development frameworks and the critical role security plays within them. In this first article, we’ll focus on the essentials: how the Product Development Life Cycle (PDLC) provides the overarching structure, while the Software Development Life Cycle (SDLC) operates as a vital component within it. In part two, we’ll shift our focus to security, examining how it threads through both frameworks and the need to shift to a more comprehensive approach. Ready to dive in? Let’s begin.

‍

Your Software is a part of your Products

Building software today is no small feat. It requires a balancing act of speed, complexity, and quality. In today’s world, when we hear the word “product,” one of the first things that comes to mind (if not the one and only) is software. Whether it’s a sleek app, a powerful platform, or a seamless service, software has become the heart of modern products. But this shift has created a unique challenge: there are frameworks designed for building products and frameworks specifically for writing software. And because software often is the product, it’s easy to see why these two distinct types of frameworks frequently get blurred together.

‍

PDLC (Product Development Life Cycle) and SDLC (Software Development Life Cycle) are two of the most fundamental frameworks in the tech world, yet they’re often treated as synonyms. On the surface, it’s understandable since both are about planning, creating, and delivering something of value. However, PDLC and SDLC serve very different purposes. PDLC is about the what and why of the product; defining goals, understanding user needs, and planning how to meet them. SDLC, on the other hand, zeroes in on the how; the technical process of designing, coding, testing, and deploying the software to deliver the what.

‍

When these frameworks get confused, it can lead to misaligned priorities, poor communication, wasted effort and siloed security approach. Teams might overlook the big-picture strategy while getting lost in technical execution, or vice versa. And in a world where software is the backbone of most products, understanding the difference between these two frameworks isn’t just helpful but rather critical for building successful, scalable, and secure solutions. Let’s unpack how PDLC and SDLC work together.

‍

Comparing the PDLC and the SDLC

• ‍PDLC (Product Development Life Cycle) is the end-to-end process that guides a product from an initial idea through research, design, development, launch, and ongoing refinement until eventual retirement. It looks beyond just the code, focusing on business goals, market needs, and the full customer experience
• ‍SDLC (Software Development Life Cycle) is the structured approach within the PDLC that specifically addresses the creation and maintenance of the software components. It provides a methodical framework for planning, building, testing, deploying, and maintaining the software so that it meets its requirements effectively

Put simply, PDLC orchestrates the entire product journey, while SDLC concentrates on how the software inside that product is built and kept running.

‍

‍

Think of PDLC as the overarching blueprint you’d use to craft a bestselling book. It starts with understanding your audience, picking the right genre, outlining the story’s arc, and planning how you’ll publish, distribute, and market the final work. SDLC, on the other hand, is like the detailed process of writing the chapters, editing each sentence, fixing plot holes, and ensuring the language flows smoothly. In other words, while the PDLC is about shaping a novel that resonates with readers and finds success in the market, the SDLC is about making sure the prose itself is strong and coherent. Without a solid PDLC to guide the SDLC, you might write a beautifully polished manuscript that no one wants to read or overlook security risks that arise from decisions made outside the text itself.

‍

Compliments not Competitors

While it’s tempting to think of product and software as interchangeable in today’s world where most products are software-based, they are not the same. Each requires its own methodology, and understanding the distinctions between PDLC and SDLC is key to ensuring success. That said, it’s not about choosing one over the other; it’s about recognizing how they complement each other. Ignoring either framework means risking critical oversights and especially when it comes to security which can lead to far-reaching consequences.