For security platforms

Zero-ETL graph analytics for cybersecurity at scale.

Analyze connected security risks in real time across assets, identities, permissions, and findings. PuppyGraph runs graph queries directly over existing security data, without a separate graph database to load and synchronize.

EXPOSUREIDENTITYDATAassumescan accessExposed assetService roleSensitive dataFindingAsset contextOther resourcePuppyGraphExisting security dataAssets · Identities · Permissions · FindingsEXPOSUREExposed assetOther resourceIDENTITYService roleDATASensitive dataassumescan accessFindingAsset contextPuppyGraphExisting security dataAssets · Identities ·Permissions · Findings

Trusted by the world’s leading cybersecurity companies

  • Palo Alto Networks
  • Datadog
  • Netskope
  • TrendAI
  • Sola Security
  • Prevalent AI
  • Traceforce

01 / Customer stories

Security platforms already run this way.

Security teams use PuppyGraph to build applications and investigate connected risks. Their work spans asset intelligence, contextual investigation, threat research, and more.

Botnet identification and tracing

Palo Alto Networks researchers use PuppyGraph to identify and track botnets in traffic logs stored on Apache Iceberg. Graph queries connect command-and-control servers with victim nodes, while a tracing dashboard follows their activity over time.

“For a user-facing application, query latency and data freshness are non-negotiable. PuppyGraph allows us to execute multi-hop graph traversals directly on our existing data platform without moving or duplicating a single row. By removing the ETL bottleneck, we eliminated pipeline maintenance entirely while delivering lightning-fast graph analytics to our end users in real time.”
Ran XiaEngineering Director, Palo Alto Networks
Read the case study →

AI-native asset intelligence

Sola Security connects assets, identities, and security knowledge in a graph-based intelligence layer. Relationship context and a defined scoring model give analysts and AI assistants a consistent basis for prioritizing assets.

“We run AI agents across thousands of tables and billions of edges a day. Two years ago, I’d have told you the graph side alone made this impractical at this scale. It’s one of those products where you ask: how is this just now?”
Leon GoldbergCTO, Sola Security
Read the case study →

Cyber knowledge graph

Prevalent AI uses PuppyGraph to query its cyber knowledge graph on Apache Iceberg. Analysts explore relationships across people, hosts, and vulnerabilities through self-service dashboards and Navigator’s conversational analytics.

“We found that GPEs like PuppyGraph—especially in cached mode—excel at analytical and summarization use cases, outperforming most graph databases by a wide margin.”
Namith CholappurathHead of Architecture, Prevalent AI
Read the case study →

02 / Graph analytics for security

Follow the connections behind security risks.

Connect assets, identities, permissions, and findings to trace access paths, explore potential impact, and investigate alerts in context.

Examples use simplified graph models. Adapt labels and properties to your schema.

01

Attack-path analysis

Which access chains connect an exposed asset to sensitive data?

Follow role and permission relationships to surface paths that warrant investigation.

assumescan accessVMExposedRolePermissionsStorageSensitiveOther resourceassumescan accessVMExposedRolePermissionsStorageSensitiveOther resource
View Cypher example

Set $assetId to the exposed asset. CAN_ASSUME and CAN_ACCESS represent access relationships prepared from your security data.

MATCH path = (asset:Asset)-[:CAN_ASSUME]->(role:Role)
             -[:CAN_ACCESS]->(data:Resource)
WHERE asset.id = $assetId
  AND asset.exposed = true AND data.sensitive = true
RETURN path
LIMIT 25

Returns: Up to 25 modeled access paths from the selected exposed asset, through a role, to sensitive resources. A modeled path warrants investigation; it does not prove exploitability.

02

Blast-radius analysis

What could a compromised identity or asset reach?

Explore connected resources and services to assess potential impact and inform containment decisions.

IdentityCompromisedVMStorageServiceDataIdentityCompromisedVMStorageServiceData
View Cypher example

Set $identityId to the identity under review. CAN_REACH represents directed reachability established by your access model.

MATCH path = (identity:Identity)-[:CAN_REACH*1..3]->(resource)
WHERE identity.id = $identityId AND resource <> identity
RETURN DISTINCT resource.id AS resourceId, path
LIMIT 25

Returns: Up to 25 resource/path pairs within three modeled reachability links. Review the supporting path to assess potential impact.

03

Contextual investigation

Which identities, assets, and findings are connected to an alert?

Bring related evidence into the investigation so analysts can understand the conditions surrounding an individual signal.

AssetAffectedIdentityAssociatedVulnerabilityOn the assetFindingRelatedAlertAssetAffectedIdentityAssociatedVulnerabilityOn the assetFindingRelatedAlert
View Cypher example

Set $alertId to the alert under review. RELATED_TO links it to the assets, identities, vulnerabilities, and findings associated by your security pipeline.

MATCH (alert:Alert)-[:RELATED_TO]-(context)
WHERE alert.id = $alertId
RETURN DISTINCT context
LIMIT 25

Returns: Up to 25 distinct context records associated with the alert, without treating those associations as an attack sequence.

03 / From security data to graph analytics

Run graph analytics directly on security data.

The data behind security analysis already lives in existing tables. PuppyGraph maps those tables into a graph model and queries them directly, without a separate graph database to populate and synchronize.

Traditional approach

Copy data. Keep two systems in sync.

ETL + duplicate storage + ongoing sync

  1. Curated security tables
    IcebergClickHousePostgreSQLDuckDB
  2. Build and run a graph-loading pipeline
    ExportTransformLoad
    Export, transform, load, then synchronize changes
  3. Operate a separate graph databaseStore and maintain another copy of the data
    Keep the graph copy in sync
  4. Security analytics
  • More pipeline work. Propagate updates, backfills, and schema changes into the graph copy.
  • Another system to operate. Manage graph storage and the synchronization jobs alongside your data platform.

With PuppyGraph

Query existing data. Skip the graph copy.

Zero-ETL · Query data in place

  1. Curated security tables
    IcebergClickHousePostgreSQLDuckDB
  2. PuppyGraph queries source tablesMap tables to vertices and edges in a graph schema
  3. Security analytics
  • No graph-loading pipeline. Query your existing security tables through the graph model.
  • No separate graph data store. Keep your source data in the platform you already operate.

Connect to an existing identity provider, assign roles for graph queries and administration, and scope data visibility with entitlement-based row filters. Explore access controls →

04 / Performance & scalability

Built for security data at scale.

Security data can reach terabytes or petabytes. Moving that data into a separate graph database adds another system to load, store, and scale. PuppyGraph brings graph analytics to the existing data platform, with distributed compute for demanding security queries.

Optimized for graph queries.

PuppyGraph plans and executes traversals as node and edge operations in its own distributed engine. That lets it optimize specifically for multi-hop analysis and graph pattern matching.

Less data to scan. More work per batch.

Columnar execution reads the attributes a query needs, while filters and data statistics reduce scanning. Vectorized processing evaluates data in batches to reduce execution overhead.

Distribute the work as demand grows.

PuppyGraph automatically distributes query work across compute nodes. Add nodes to expand query capacity as security workloads grow, with compute scaling independently of the underlying data storage.

5–10 PB

Data volume in production

< 1 sec

6-hop query across 600M edges

Build a security graph layer

Build a security graph on the data you already have.

Download PuppyGraph to start querying relationships across identities, assets, and vulnerabilities. Book a demo to explore your security use case, or join Slack for support from our engineering team.

$ docker run -p 8081:8081 \
  -p 8182:8182 -p 7687:7687 \
  puppygraph/puppygraph:latestPulling puppygraph/puppygraph:latestStarting PuppyGraphWeb console listening on 0.0.0.0:8081Gremlin endpoint listening on 0.0.0.0:8182PuppyGraph is running# no pipelines · no second database · no data movement