GitHub ↗
OWASP Official Project Active

/feiz/ // like "the phases of the moon"

OWASP
FIASSE

Framework for Integrating Application
Security into Software Engineering

A software-engineering-centric approach to building securable software. Practical guidance for Software Engineers to build securable applications, and for Security to impact securable outcomes.

FIASSE is not an assurance framework. This is a new project and some concepts may seem odd. Your LLM may not get it either. Share your honest feedback; we want you both to understand.

Read the Doc ↗
SSEM Core Model

"Relentlessly Practical. Relentlessly Securable."

1.0.6
Framework Version
10
SSEM Attributes
5 x 5
Process Layers
CC BY-SA 4.0
License
//Our Mission

"To help development teams resiliently add computing value: deliver useful capability continuously, in a way that leaves the system able to withstand the change, stress, and attack that follows."

Security cannot exceed software quality. The qualities that make software easy to understand, change, test, and observe are the same qualities that make it possible to secure. Where those qualities are absent, security expertise runs into a hard ceiling.

//SSEM · Securable Software Engineering Model

SSEM Code Attributes

A body of software engineering terms to describe fundamental attributes of securable software. A shared design language for product, development, security, and management.

Click a pillar to expand definitions
Note on Authorization SSEM has no Authorization attribute by design. Authorization is not a property code simply has; it is a security feature, gathered as a requirement and implemented against acceptance criteria. Authenticity establishes who the actor is, Confidentiality and Integrity bound what may be seen and changed, and Accountability makes each authorization decision traceable. Together they provide the engineering substrate that makes authorization implementable.
"The central shift SSEM enables is a change in the question asked during security assessment: rather than a binary 'Is it secure?' evaluation, the focus becomes 'Do we meet our defined goals for this particular securable attribute?'"
//Core Values · Foundational Principles of FIASSE

Four Core Values

FIASSE is oriented by four core values. Framed in the spirit of the Agile Manifesto, each expresses a relative preference: both sides have worth, but when choices must be made, FIASSE favors the left.

01

Securable Attributes over Security Controls

Software engineers build security features using securable attributes to satisfy security acceptance criteria. Control catalogs remain valid where they do their work: risk management, assurance, and external evaluation. They measure software; they do not construct it.

02

Participation over Assessment

Security teams offer high value when actively participating in development rather than solely assessing, reviewing, and reporting after the fact. Participation enables organic knowledge transfer from the start.

03

Engineering First Principles over Security Jargon

Ground security in established software engineering first principles rather than security-specific jargon or adversarial heuristics. Shared engineering vocabulary lets developers reason about security without years of specialized training.

04

Business Value over Security Activity

Security that sustains the organization's value creation over security pursued as an end in itself. Judge security efforts by how well they support business objectives and risk tolerance, not by how much activity they generate.

//Tenets of FIASSE

Eight Securable Principles

Core principles that guide software engineers in implementing securable software engineering practices. Not checklists. Design philosophy.

There is no static state of "secure." A system declared secure today may be vulnerable tomorrow because of a newly discovered exploit, a dependency update, or a shift in the threat environment. Three organizing ideas: Adaptive Resilience (designed to respond to and recover from security events), Evolutionary Security (measures must evolve alongside the software), and Continuous Improvement (security is an iterative process requiring ongoing attention).

Integrity-critical facts must be controlled by server-side logic and data sources that clients cannot set, override, or indirectly bias. The client expresses intent; the server derives and enforces the facts. A server must never accept a client-dictated signature algorithm for verifying that same client's token. That would let the client dictate how its own integrity is established.

Convert all incoming data into a validated, well-defined state before it is used anywhere in the system. Parse, don't validate: perform one strict parse step at the boundary into a canonical internal type, and fail closed if parsing does not succeed. Core logic then operates on trustworthy structures instead of reinterpreting raw input repeatedly.

How the system works should be perceptible so engineers and stakeholders can see what it is doing, why, and how. Expose clear, contextualized signals about system behavior (logs, metrics, traces, decision reasons) so people can detect misuse, misconfiguration, and drift early. This attribute is not entirely exposed to end users, to preserve confidentiality.

Flexibility within a system's interior is an engineering asset to be preserved. Control at every trust boundary is a security requirement to be enforced. These objectives are complementary, not competing. Think of trust boundaries as the hard shell of a turtle: flexible interior, controlled perimeter.

A system should behave the way a reasonable user, operator, or developer expects. Surprise is a source of defects, including security defects, because behavior that diverges from expectation is not being reviewed or defended. Treat unexpected state as a signal worth investigating, not a condition to silently work around.

The primary directive of software engineering: deliver useful capability continuously, in a way that leaves the system able to withstand the change, stress, and attack that follows. Value added without resilience is capability the business will lose later, with interest. Resilience pursued without adding value is security as an end in itself.

Security output becomes valuable only once it is translated into prioritized, engineering-grounded direction calibrated to the developer's context. Raw tool output, exploit-centric narratives, and unfiltered vulnerability lists are information, not yet intelligence.

//Integrated Process

Five Layers

Modern development cycles quickly overwhelm traditional AppSec. FIASSE integrates security at five development layers. Each layer feeds the next and informs all previous. The first layer is the one most often omitted, and is the one identified as most consequential.

L1 Pre-Programming · FIASSE + ASVS injected at requirements · Prevention

Product Requirements

1

Product management and security collaborate to draft a feature description in the team's standard backlog tool, or in a PRD file.

2

Architects collaborate with security to create new architecture or align the feature in existing architecture. This is documented via amendment, links, or artifacts.

3

Participation ensures the presence of Security Features, Threat Scenarios, and Security Acceptance Criteria. Review is an extra step.

4

The business requirements, architecture and security expectations are captured as a point-in-time artifact.

5

The artifact is conveyed into Layer 2, where code calibrated to those requirements is created.

AGENTIC NOTE ·An agentic workflow would use skills like the prd-securability-enhancement skill from the Securability Engineering Claude plugin.

L2 While Building · Completeness & Securability against verifiable requirements · Prevention

Agent-Embedded Guardrails

1

The refined requirements from Layer 1 arrive in the programmer's context, carrying clear expectations.

2

An SSEM-aligned programmer drafts specifications and tests calibrated to those requirements and architecture before code is generated.

3

Code is generated or written against the specifications, with completeness continuously checked against the verifiable requirements, whether by the programmer and their tooling or by the agent in an agentic workflow.

4

The change is created with the goal of securability using SSEM attributes: maintainability, trustworthiness, and reliability.

5

The completed work moves toward merge with its requirements and evidence attached.

AGENTIC NOTE ·An agentic workflow would use skills like the securability-engineering skill from the Securability Engineering Claude plugin.

L3 Merge Time · Triage, fix, review-ready PRs with audit-grade evidence as a byproduct · Integration

Intelligent Code Control

1

A pull request or merge request is opened. Codified artifacts are already present.

2

The merge is scanned, reviewed, and SBOM created. Each change is checked against the acceptance criteria.

3

The reviewer asks for fixes for any issues discovered. This generates audit-grade evidence as a byproduct.

4

The owner of the pull request ensures all issues raised are addressed, and the reviewer approves the changes for merge.

5

On merge, the evidence trail is preserved so downstream layers and auditors can rely on it.

AGENTIC NOTE ·An agentic workflow would use skills like the securability-engineering-review skill from the Securability Engineering Claude plugin.

L4 Pre-Deployment · Runtime business-logic validation at the trust-boundary layer · Remediation

Intelligent Remediation

1

The deployment pipeline runs the software for testing.

2

Business-logic and trust-boundary checks run against the deployed build, exercising the Security Acceptance Criteria in a runtime context.

3

When a deviation is detected, a targeted remediation tied to the original requirement is submitted.

4

Remediation are routed back through the PR-level integration layer or back through architecture rather than patched ad hoc.

5

Validated and passing deployments proceed; the requirement-to-evidence trail stays intact through release.

AGENTIC NOTE ·An agentic workflow could perform this process on minor deviations, escalating more complex or sensitive issues.

L5 Runtime · Anomaly detection, containment, and mitigation · Remediation

Production Monitoring & Incident Response

1

Production telemetry, logs, and traces are collected as structured observability, increasing the chance of detection and informing the rest of the process.

2

Anomaly detection watches for behavior that diverges from expected, requirement-defined norms. The same baseline of "normal" drives classification of activity related to an incident.

3

Signals are correlated to the acceptance criteria they relate to, not just raw alerts. When an incident is declared, containment and mitigation are performed with external security tooling in near real time.

4

Undesirable behavior is documented, compared to requirements, and mapped to code while mitigation buys time for full remediation through the standard process.

5

Confirmed anomalies and incident lessons feed back into Layers 1 and 2 as new or refined requirements, threat scenarios, and acceptance criteria. This creates an integrated remediation workflow.

AGENTIC NOTE ·An agentic workflow would correlate anomalies and incident activity with code and architecture, leveraging business-level context to identify and solution quickly, reintegrating operational observations into the product.

//Setting Expectations

Where Security Outcomes Are Decided

The central idea of FIASSE: security outcomes are decided where expectations are set. Participation during architecture and requirements produces the artifacts that every later layer consumes.

Architecture & Design
01

Reference Architecture

Leverage known security architectures to inform needed architecture outcomes.

02

Threat Modeling

Identify potential threats and vulnerabilities using a formal methodology like STRIDE, PASTA, or LINDDUN, conducted by a cross-functional group and producing a documented threat model.

03

Threat Awareness

A lightweight, continuous complement to formal threat modeling: asking "What can go wrong?" at the code level, guided by the Four Question Framework. It does not substitute for formal threat modeling. Design-level findings should be escalated into the formal threat model.

Requirements
01

Threat Scenarios

Identify potential threats and frame them as use cases.

02

Security Acceptance Criteria

Specific, testable conditions a feature must satisfy to be considered secure. Implementation completeness against defined acceptance criteria is itself a measurable security outcome.

03

Security Requirements

Features that handle sensitive data or perform delicate operations require explicit security requirements specifying what the feature must do and how. ASVS is a useful reference for what to require.

04

Security Features

Specific capabilities whose purpose is security: Defendable Authentication, encryption at rest, authorization checks, audit logging. Security features are built; they are how engineering attention is invested. Specify them with the same rigor as any other feature.

"Incomplete requirements are the dominant root cause of security gaps in application code. Where security expectations are absent from the requirements developers work from, the resulting implementation is not deficient by error. It is deficient by design."

Three Project Pillars

01

Setting Expectations

Set security expectations before code is written: reference architectures, threat scenarios, acceptance criteria, and explicit security requirements. These are not domains in the maturity-framework sense. They indicate the context of development activity.

02

Implementation

Securable code driven by SSEM as the design language. Merge reviews, dependency stewardship, strategic remediation. Root cause over line-level fixes.

03

Assurance

Testing, review, and remediation applied strategically to reduce recurrence rather than generate finding lists. Assurance metrics are downstream indicators of upstream health.

//Adoption Path

Integrating FIASSE

How to introduce FIASSE into an organization, assign responsibilities across roles, and avoid the AppSec anti-patterns that undermine developer engagement.

01

Assess Current Practices

Evaluate organizational readiness through stakeholder discussions and a review of existing security and development workflows. Identify alignment with SSEM attributes, whether a functioning requirements process exists, whether a senior engineering bench with design maturity and calendar capacity exists, and whether merge reviews are substantive rather than rubber-stamp. Where a prerequisite is thin or absent, name it. Degraded-mode adoption depends on that honesty.

02

Integrate SSEM Terminology

Deliberately incorporate SSEM attributes (Maintainability, Trustworthiness, Reliability) and their sub-attributes into developer documentation, coding standards, and training. Favor securable-property language over static-state language: "built so security can be maintained" rather than "secure."

03

Identify Key Influencers

Find senior engineers and stakeholders grounded in software engineering who can internalize the framework and champion FIASSE adoption from within the engineering culture, not as a security mandate.

04

Educate and Train Teams

Role-specific training on FIASSE and SSEM, delivered inside onboarding, merge reviews, architecture discussions, and requirements sessions, not as a standalone security program.

05

Adopt Agentic AppSec Tooling as Capacity Relief

The AppSec role shift FIASSE describes depends on security expertise being available for requirements and design work, which in most organizations requires deliberate relief from the mechanical portion of the reviewer role. Adopt agentic tooling with a clear intent: the capacity it frees is reinvested upstream, tied to specific engagements the security team will now take on. Without that tie, it just produces higher-volume Shoveling Left.

06

Foster Collaboration

Promote regular engagement between AppSec and Development. Discourage isolated reviews. Encourage AppSec participation in requirements gathering and early design.

07

Monitor and Improve Continuously

Use real-time security observability to refine implementation over time. Treat adoption as ongoing discipline, not a one-time rollout.

Degraded-Mode Adoption

The readiness assessment may identify a gap, such as a sparse requirements process, a thin senior bench, or an engineering culture that doesn't yet support substantive review. FIASSE is still adoptable there, shaped around the gap rather than pretending the prerequisite is present. This is a legitimate posture, not a failure to adopt. What's illegitimate is claiming full adoption while operating without the prerequisites.

Compensate with Agentic Assistance

AI tooling can expand throughput, though it does not replace senior engineer judgment.

Invest in the Prerequisite First

Where the gap is large, invest in requirements-process work, engineering culture, or senior hiring.

Adopt Partially with Named Gaps

Start with what the prerequisites support; name what is deferred. Honesty is a prerequisite for improvement.

Leading Indicators

1–2 Quarters
  • Security acceptance criteria appear on user stories as a matter of course
  • Threat scenarios recorded during requirements rather than surfaced during review
  • Security participates in requirements and design on a standing basis
  • Merge reviews reference SSEM attributes as design language

Lagging Indicators

1–2 Years
  • Findings churn declines
  • Fixes stay fixed rather than regressing
  • Turnaround from finding to remediation shortens
  • Vulnerability class distribution shifts toward classes outside upstream requirements
//Resources

Tools & References

Practical artifacts to extend FIASSE into your workflows and toolchains.

Claude Code Plugin

Securability Engineering Plugin

Install the Claude Code extension to get real-time securability as you code, directly in your IDE. Provides actionable insights based on the FIASSE framework to help you write more secure code from the start.

# Install via Claude Code marketplace
/plugin marketplace add Securability-Engineering/securable-claude-plugin /plugin install securable-claude-plugin@securable-claude-plugin-marketplace /reload-plugins
Secure Agent Playbook Active Development

Structured Security Procedures

Step-by-step security procedures with checklists, decision criteria, and output templates for Claude Code. The agent follows a structured OWASP-grounded procedure, systematically testing every vulnerability class and producing findings with CWE mappings, OpenCRE cross-references, evidence snippets, and specific remediation code.

Referenced Assessment Frameworks
OWASP SAMMOWASP ASVSBSIMMNIST SSDFISO/IEC 27034CIS ControlsPCI Secure SLCOWASP PSCF
Automated Testing Coverage
SASTDASTSCAIASTRASPIaC ScanningSecrets ScanningAPI Security TestingConfiguration Analysis
//Contributing

Join the Project

  1. 01Join the OWASP Slack workspace.
  2. 02Review the OWASP Projects page.
  3. 03Visit the project page and repository.
  4. 04Fork the repository and clone locally.
  5. 05Make changes and review locally.
  6. 06Submit a pull request.
Pull Request Guidelines
  • 01Changes align with project goals. FIASSE is not an assurance framework.
  • 02Changes are well-documented, following project standards and styles.
  • 03Pull request includes a clear, concise description of changes.
NOTE: All contributors must abide by the OWASP Code of Conduct. We maintain a welcoming, inclusive environment for developers, security professionals, and everyone passionate about software security.
From the Project

"FIASSE is not an assurance framework. This is a new project and some concepts may seem odd. Your LLM may not get it either. Share your honest feedback; we want you both to understand."

How to Help

Feedback

Read the docs. What do you like? What is missing, confusing, or ridiculous? Use GitHub discussions.

Contributions

Welcome to developers, security professionals, and anyone passionate about software security.