Storage and processing

When a workflow runs on the server, the workflow engine stores every upload, connector read, transform output, and export on encrypted storage inside your workspace. Fontana is built around a small set of data principles so operators, auditors, and downstream systems can trust what was computed, what was changed, and what can be reproduced.

Core Fontana data principles

Principle	In one sentence
Immutable	Data input or engine output is never overwritten; corrections are explicit audited overlays.
Durable	Run data survives restarts and upgrades and upstream data changes - on encrypted, workspace-scoped storage.
Repeatable	Each run is its own snapshot; selective re-runs refresh only what changed.
Auditable	Validations, transforms, and manual edits leave structured audit evidence.
Transparent	Every node output is captured, inspectable in Flow, exportable, and explorable by you and your agents.
Queryable	Datasets stay in Apache Arrow so you can inspect, filter, and query them in Flow.
Isolated	Your data stays in your workspace cluster unless you choose to export it.

Immutable

Fontana treats processor output as immutable. When a node executes, it produces a new dataset for that port. The engine does not mutate the raw output from a previous execution in place.

Manual cell and header edits in the Flow grid follow the same rule. Your corrections are stored as separate overlays and merged only when you view data or when downstream nodes consume a port. The underlying computed dataset remains available for audit and replay.

That separation matters for compliance: you can always distinguish what the workflow calculated from what a person changed afterward.

Durable

Workflow data lives on dedicated encrypted storage attached to your workspace as persistent volumes.

Encryption at rest on production deployments protects uploads, run datasets, and exports at the infrastructure layer.
Survives restarts and upgrades within your workspace so a platform update does not wipe active or historical runs.
Connector output from PyAirbyte is written to the same durable store as File Input and transform results, keeping ingress and processing inside one boundary.

See Security for the broader encryption and isolation control model.

Repeatable

Every workflow run is a discrete snapshot: uploads and connector reads for that execution, node outputs as the graph runs, audit and lineage metadata, and any export files generated along the way.

When inputs or node configuration change, the reactive engine re-runs only the affected branches. Unchanged branches can reuse prior results where hashes match, so you get predictable refreshes without recomputing the entire graph every time.

You can open an earlier run in Flow, compare outcomes, and download exports from that point in time without losing newer runs on the same workflow.

Auditable

Fontana records audit items throughout execution and review:

Validation and transform events - warnings, errors, and operation summaries on retained rows
Manual edits - row, column, previous value, new value, and timestamp for every grid correction
Data lineage - pointer-based provenance from an output cell back through the workflow graph to sources (see Data lineage)

Together, these signals support operational troubleshooting and compliance review. They describe workflow data quality and provenance. For sign-in, admin, and cluster events, see Immutable audit trail.

Transparent

Every step of a workflow is inspectable and exportable. Fontana captures the result at each node and surfaces it in the app, so you never work blind through a black-box pipeline.

On the canvas, open any node to review its output port: row counts, validation signals, and the full dataset behind that step. The same run data is available across Flow:

Data grid - tabular view of each port, with your edits applied when viewing; edited cells show markers on the canvas
Audit panel - filterable audit items for the active run
Data Lineage panel - walk from a selected cell back through transforms, lookups, and sources (see Data lineage)
Export - download node or run outputs via Save File Export and related egress paths (see Egress)

You and your governed AI agents can work with that captured data directly: explore ports in the UI, run queries against run datasets in the workflow or grid, or use AI chat and inference to ask questions, summarize results, and analyze patterns on the data your workflow produced. Transparency means the platform exposes what ran at every step; you choose how to inspect it, query it, or reason over it.

See Governed AI for agents, tools, and model access on workflow context.

Queryable

Fontana stores run datasets in Apache Arrow, an open columnar format designed for analytics workloads. Columnar layout keeps large tables efficient for transforms, connectors, validation, and interactive review.

In practice you can:

Browse and filter port data in the Flow data grid
Run Query nodes in a workflow using SQL and other supported query modes against run datasets
Let governed agents query approved run data where your RBAC and workflow design allow it
Export to CSV, Excel, JSON, and other formats for tools outside Flow (see Egress)

Queryable storage closes the loop: data is not only stored safely, it stays usable inside the platform and portable when you need it elsewhere.

Isolated

Your workspace is a separate cluster with its own storage, secrets, and identity plane. Workflow data is not co-mingled with other customers on the platform.

Data leaves that boundary only when you configure egress: Save File Export, REST or GraphQL API nodes, downstream connectors, or other delivery paths you approve. Platform operation itself does not require shipping your datasets to a shared Fontana-operated data pool.

Ingress - how data enters your workspace
Egress - downloads and downstream delivery
Data lineage - atomic provenance and OpenLineage export
Security - encryption at rest and workspace isolation
Compliance evidence - data lineage and audit evidence
Workflow orchestration - reactive execution and document parsing