The Data-First Principle

SignStack's core difference is its data-first approach. Unlike traditional platforms centered on static documents, SignStack uses structured data as the primary driver of your workflows. Documents become dynamic views reflecting this data.

Understanding this principle unlocks SignStack's power for building intelligent, reactive processes.

Entities: Your Business Data

At the heart of SignStack are Entities. These are simply the structured JSON objects representing your core business concepts – a ClientInfo object, a DealInfo object, a PropertyInfo object, etc. These are the familiar data structures you work with in your own applications.

Schemas: Defining Structure & Ensuring Integrity

SignStack uses Schemas to understand and validate your entity data.

The Contract: A Schema defines the expected structure and rules for an entity type (e.g., ClientInfo must have an email field).
Open Standard: We use the open JSON Schema standard, providing robust validation (data types, required fields, formats) transparently.
Guaranteed Integrity: By defining explicit schemas that you control, you ensure data consistency throughout your workflow, reducing errors.

You manage your reusable Schemas using the /schemas API or the "Schemas" section in the dashboard.

The Entity Context: The Workflow's Data State

For any single, running Workflow, the collection of all its current entity instances forms the Entity Context.

The Authoritative Data State: This context holds the canonical data for that specific transaction. Think of it as the authoritative data record for that specific point in the workflow's execution.
Driving Dynamic Documents with JSONata: This is where the "data-first" magic happens. SignStack uses the powerful, open-standard JSONata expression engine to make your documents dynamic views that read directly from the EntityContext.
- Expressions you define for a field's value (valueExpression) execute logic using data from the context to calculate its value.
  - Simple Example (1-to-1 Mapping): Display the client's name directly from the ClientInfo entity:
```
entities.ClientInfo.name
```
  - Advanced Example (Combining Data): Calculate a priority fee field's value based on both the deal size and the client's status:
```
"$formatNumber(ClientInfo.tier = 'Premium' and DealInfo.value > 50000 ? DealInfo.value * 0.02 : 0, '$,0.00')"
```
- Expressions for a field's visibility (displayCondition) execute logic using data from the context to determine if that field should even be shown. For example, only show a "Manager Discount Approval" field if the requested discount exceeds the sales rep's authority limit: "DealInfo.requestedDiscount > UserInfo.discountLimit". Your documents automatically react to the current state of the data using this flexible expression language.
- 💡 Tip: Need help writing a complex expression? Modern Large Language Models (LLMs) like ChatGPT or Gemini are excellent at generating JSONata expressions based on natural language prompts!
Evolving Data: As a workflow progresses, information collected from participants can be used to update the entities within this context using features like onCompleteMappers. (You'll learn more about mappers in the Guides section). This allows the workflow's data state to evolve based on the process.

This EntityContext, combined with the power of JSONata, ensures your documents are always reflecting the most up-to-date, canonical data for the transaction.

Data History: The Audit Trail ️

Because the Entity Context evolves, SignStack automatically maintains an immutable history of these data changes.

Track Every Change: Every update to an entity creates a historical record linked to the specific workflow step that caused the change.
Complete Audit & Replay: This provides a detailed, auditable trail of how the data evolved throughout the transaction, enabling powerful debugging features like "Workflow Replay."

Why Data-First Matters

This architecture provides significant advantages:

Centralized Business Logic: Instead of scattering field calculation and display logic throughout your application code, you can define it declaratively within your SignStack Templates (valueExpression, displayCondition) and Blueprints (onCompleteMappers). This keeps all agreement-related logic in one place, making your application code cleaner and the entire process easier to audit and maintain.
Reactive Workflows: Documents dynamically reflect the current state of your business data, automatically updating as the EntityContext evolves.
Clean Application Code: Your application interacts with structured Entities, significantly reducing the amount of boilerplate code needed to manage individual document fields.
Robust Auditing: The data history provides unparalleled detail for compliance and debugging.
AI & Analytics Ready: Structured, historical entity data is a perfect asset for AI and business intelligence.

By centering on structured data and providing tools to encapsulate logic within the platform, SignStack enables a more powerful, flexible, maintainable, and intelligent approach to agreement automation.

➡️ Next: Core Concepts: Templates