DFD
DFD ingestion & versioning
Source of truthIngest DFD JSON with trust zones, processes, entities, data stores, and flows. Every upload becomes a versioned snapshot per system with history and diffs.
DFD-native
★API-first threat modeling for modern engineering teams
Turn static DFD diagrams into living, versioned threat models your teams can automate and review.
terep ingests DFD JSON, builds a System Knowledge Graph, runs a rule-based STRIDE engine, and gives security and engineering teams versioned threat models, diffs, and Mermaid diagrams via API.
AR
ML
JC
+
Ingest DFD JSON from your existing diagram tools
Build a live System Knowledge Graph from every architecture
Generate STRIDE threats, versions, diffs, and Mermaid diagrams via API
AI
terep workspaceThreat modeling · API-first
24 systems · 186 DFD versions
STRIDE threatsFrom latest DFD
Critical 18High 42
All threatsSTRIDE · High & CriticalNew vs resolvedBy trust zone
Unencrypted PII crossing an untrusted boundaryCritical
Checkout flow · WebFlagged by STRIDE engine in latest snapshot
Missing auth on internal admin endpointHigh
Admin API · ServicesDetected in DFD version v12 → v13 diff
Sensitive data logged in shared componentHigh
Logging pipeline · SharedLinked to trust zone crossing in SKG
Over-privileged access between servicesMedium
Payments cluster · ServicesHighlighted in threat snapshot history
Posture overviewLast 30 days
92
Threats reviewed+4.2x
Systems with current model97%
Systems & snapshotsPer workspace
Systems modeled24
DFD snapshots186
Threat snapshots342
Mermaid diagrams58
Modeling viewsUp to date
SystemsDFDsSKGThreatsMermaid
Product workflow
From DFD JSON to STRIDE threats, history and diagrams.
Define systems, ingest DFDs, run a rule-based STRIDE engine and keep every threat model snapshot versioned—with SKG views and Mermaid diagrams for reviews.
- 01Create & authenticate~4 min
Bootstrap terep and create your first system
Use /auth/bootstrap and /auth/login to create an admin or modeler, obtain a JWT, and define the systems you want to threat model via POST /systems.
- 02Ingest DFD JSON~8 min
Push architecture diagrams into terep as versioned DFDs
Export or generate DFD JSON from your favorite modeling tools and send it to POST /systems/{systemId}/dfd/json to create a versioned snapshot of your architecture.
- 03Run STRIDE~12 min
Generate a rule-based STRIDE threat model in one call
Call POST /systems/{systemId}/threats with { "methodology": "STRIDE" } to build the System Knowledge Graph, run rules, and store a structured threat model snapshot.
- 04Diff & visualize~16 min
Track change over time and share diagrams
Use /dfd/versions, /threats/versions, and the diff endpoints plus /skg/mermaid and /skg/mermaid/threats to review history, compare snapshots, and embed diagrams in docs and wikis.
Workflow previewTemplate • Multi-canvas
Threat modeling runLatest snapshot
DFD JSON
SKG build
STRIDE threats
DFD snapshot
Versioned architecture view
System Knowledge Graph
Normalized nodes, flows, trust zones
STRIDE threat model
Snapshot with categories and severity
4x faster from diagram change to updated threats
•DFD, SKG and STRIDE snapshots stay in sync as systems evolve.Core capabilities
Everything you need to turn architectures into living threat models.
From DFD ingestion and SKG to STRIDE snapshots and Mermaid diagrams, terep gives security and engineering teams an API-first threat modeling backbone.
SKG
System Knowledge Graph
Normalize architecture into a graph that captures nodes, edges, and trust boundaries. Use it as the backbone for rules, analytics, and visualizations.
DFD-native
ST
STRIDE engine & snapshots
Run a rule-based STRIDE engine on the latest DFD to generate structured threats, store snapshots in Mongo, and compare how risk changes over time.
DFD-native
MM
Mermaid diagrams & overlays
Export SKG views as Mermaid diagrams—with or without threat overlays—so you can embed architecture and risk views into docs, wikis, and reviews.
DFD-native
AR
Auth & role-based access
Secure access with JWT auth and roles for admins, modelers, and readers. Keep modeling workflows controlled while letting stakeholders explore safely.
DFD-native
API
API-first integration
Automate threat modeling from CI/CD, architecture reviews, and custom tooling. terep exposes every capability via HTTP APIs designed for automation.
DFD-native
Why terep
What changes when your threat models live in terep, not scattered docs.
Compare static diagrams, spreadsheets, and generic GRC tools with an API-first backend that stores DFDs, SKG views, STRIDE snapshots, and diffs in one place.
| Category | Static diagrams & slides | Spreadsheets & trackers | Generic GRC tools | terep |
|---|---|---|---|---|
| Architecture source of truth | Scattered files and screenshots | Linked out to docs and tools | High-level systems, not DFD-native | DFD-nativeVersioned DFD JSON per system with SKG views |
| Threat modeling method | Workshops, manual checklists | Columns for STRIDE, manual updates | Questionnaires and controls | DFD-nativeRule-based STRIDE engine over a System Knowledge Graph |
| History & diffs | Rarely captured or hard to compare | No snapshot concept, copy-paste history | Process audits, not model diffs | DFD-nativeSnapshot history and DeepDiff for DFDs and threats |
| Integration | Not API-driven | Email and CSV uploads | Limited technical API usage | DFD-nativeAPI-first, CI/CD and tooling friendly |
terep is built for continuous, API-first threat modeling.•Not a generic dashboard—a DFD- and STRIDE-aware backend that keeps architectures, threats, and history in sync.
Posture & analytics
Security posture at a glance for every modeled system.
Use ready-made views for systems modeled, DFD versions, threat snapshots, STRIDE distribution, and open vs resolved threats—then tailor them to each workspace and stakeholder.
Scroll to browse posture views6 views • posture & analytics
Systems modeled
See how many systems are actively modeled in terep and how coverage grows over time.
Systems modeledLive inventory
Payments APICurrent snapshot
Identity platformCurrent snapshot
Data warehouseModeling snapshot
All systemsLive inventory
Exec-readyDesigned for threat modeling & exec reviews
DFD versions over time
Track how many DFD snapshots you create per system and where the architecture is changing most.
DFD versionsLast 90 days
v8
v7
v6
v5
Checkout flow refactor+3 threats
Service split: billing+1 threat
Baseline payments architectureNo change
Initial importNo change
DFD snapshotsChange tracking
Architecture history • Last 90 daysDesigned for threat modeling & exec reviews
Threat model snapshots
Visualize snapshots generated via /threats and see how often STRIDE runs per system.
Threat snapshotsSTRIDE · Latest 3
#34a7
NewPost-release42 threats
#33f2
BaselinePre-release39 threats
#329b
EarlierDesign review36 threats
Threat modelsContinuous modeling
Risk evolution • SnapshotDesigned for threat modeling & exec reviews
Threats by STRIDE category
Break down threats by STRIDE category and severity to understand where risk clusters.
STRIDE distributionRolling 30 days
Spoofing
Tampering
Repudiation
Info Disclosure
DoS
Elevation
STRIDE categoriesRisk profiling
Threat analytics • Rolling 30 daysDesigned for threat modeling & exec reviews
Open vs resolved threats
Compare newly introduced, resolved, and unchanged threats between snapshots using diff APIs.
Open vs resolvedSnapshots
Now↑ more resolved
1 snapshot agoStable
2 snapshots ago↑ more open
ResolvedNewUnchanged
Threat lifecycleReview support
Lifecycle • Current periodDesigned for threat modeling & exec reviews
Risk by trust zone
Summarize risk by trust zone or boundary to highlight where sensitive flows cross.
Risk by trust zoneQuarter
Core services
DMZ
Public internet
Highlight where sensitive flows cross boundaries so reviews focus on the riskiest trust zones.
Trust zonesHotspot mapping
Architecture hot spots • QuarterDesigned for threat modeling & exec reviews
Before vs after terep
See how living threat models change your reviews.
Compare static diagrams and spreadsheets against an API-first backend that keeps DFDs, STRIDE snapshots, and diagrams versioned over time.
Before terep
Threat models live in scattered diagrams, docs, and spreadsheets with no single place to see history.
Manual flow
Modeling cadenceManual updates
Hours spent reconciling diagrams and risk registers
No consistent way to diff architectures or threats
Hard to prove ongoing threat modeling to auditors
Tools & surfacesPer-tool
DFDsScattered
SKG viewsScattered
Threat snapshotsScattered
Mermaid diagramsScattered
VersionsScattered
DiffsScattered
3–5 hours / system updateOne-off workshops and documents
With terep
DFDs, threats, SKG views, and Mermaid diagrams live in one API-first platform with versioned snapshots.
Automated flow
Modeling cadenceAPI-driven updates
Minutes to regenerate STRIDE threats after a change
Snapshot history for every system and threat model
Clear diffs to support reviews and sign-off
Threat modeling workflowsUnified
DFDsIn terep
SKG viewsIn terep
Threat snapshotsIn terep
Mermaid diagramsIn terep
VersionsIn terep
DiffsIn terep
Minutes to regenerateVersioned, API-first threat modeling
Who it's for
Teams that treat threat modeling as a continuous practice.
From security architects and AppSec to DevSecOps, engineering and risk teams, terep keeps DFDs, STRIDE snapshots and history in one API-first platform.
Security architects
Use caseStandardize how your organization does STRIDE: define systems, ingest DFDs, and keep a living, versioned threat model for every critical app.
DFD- and STRIDE-native workflows
AppSec & product security
Use caseAutomate threat generation from architecture updates, plug into CI/CD, and give developers concrete STRIDE findings with diagrams.
DFD- and STRIDE-native workflows
DevSecOps & platform
Use caseIntegrate terep into pipelines so DFD changes and releases trigger new threat models, diffs, and SKG exports.
DFD- and STRIDE-native workflows
Engineering leadership
Use caseSee architecture, data flows, and risk in one place. Use history and diffs to support reviews, sign-offs, and roadmap decisions.
DFD- and STRIDE-native workflows
Risk & compliance
Use caseEvidence continuous threat modeling with versioned snapshots, STRIDE coverage, and change-aware diffs across systems.
DFD- and STRIDE-native workflows
Security services & advisory
Use caseRun repeatable, API-first threat modeling for multiple clients, with separate systems, snapshots, and diagrams per engagement.
DFD- and STRIDE-native workflows
Pricing
Pick a plan that scales with your threat modeling practice.
Start with a single system, then grow into multi-team, multi-system threat modeling—while keeping DFDs, STRIDE snapshots and diagrams in one place.
Most popular
Team
For security and engineering teams standardizing threat modeling.
Talk to us
- Multiple systems and environments
- Full STRIDE threat engine and history/diff APIs
- Role-based access control for admins, modelers, readers
- Threat overlays in Mermaid diagrams
- API-first integration for CI/CD and tooling
- Priority support
Customers
Teams that treat threat modeling as a continuous, versioned practice.
Security, AppSec and engineering leaders use terep to keep DFDs, STRIDE snapshots and diagrams in sync instead of chasing stale slides and spreadsheets.
DP
Dana PatelDirector of Product Security · Growthline Commerce
“With terep we finally have a living threat model per system. Architecture reviews are grounded in real DFDs, STRIDE snapshots, and diffs instead of static slides.”
Workflow upgraded
MY
Michael YangHead of Application Security · Northwind Bank
“The API-first flow means every major system change now regenerates a STRIDE model automatically. My team spends time validating threats, not copying them between tools.”
Workflow upgraded
SL
Sarah LopezVP Engineering · Arcadia Labs
“terep connects how we draw architectures with how we talk about risk. History and diffs make it obvious what changed, why it matters, and whether we made things safer.”
Workflow upgraded
Ready for your next architecture change
Make threat modeling continuous, not one-off workshops.
Plug terep into your DFD sources, CI/CD and review workflows so every system change regenerates STRIDE threats, updates snapshots, and keeps diagrams and history in sync.