Selected Work

Documentation Strategy · Product Communication

Complex products. Clear systems.

I design documentation ecosystems that help people understand, adopt, trust, and use digital products.

Senior technical writing, documentation strategy, developer documentation, information architecture, UX writing, and AI-ready knowledge systems for SaaS, AI, FinTech, eCommerce, healthcare, and enterprise products.

Documentation Strategy Technical Writing Developer Documentation API Documentation Information Architecture UX Writing Knowledge Systems AI-Ready Content Product Communication Enterprise Documentation
Book · AI Search & Content

AI Search and Content Strategy

A practical publication focused on structuring modern content for people, search engines, and AI-driven discovery.

View the book on Amazon
Book · Trust & Healthcare Communication

Trust as a Strategy

How healthcare organizations can attract patients, strengthen their brand, improve communication, and build sustainable profitability through trust.

View the book on Amazon
NDA

Most of my commercial work is protected by confidentiality agreements. This portfolio combines original documentation prototypes, public thought leadership, published books, and anonymized case studies to demonstrate how I approach product communication without exposing proprietary client materials.

NovaFlow Documentation Showcase
Documentation prototypes Original portfolio system

Documentation designed as a product system.

A complete documentation ecosystem created from scratch for NovaFlow, a fictional enterprise workflow platform. Every example is an original prototype built specifically for this portfolio.

NDA-safe

No client assets, confidential processes, or proprietary documentation are reproduced.

System thinking

Information architecture, terminology, navigation, and content patterns work as one system.

Production-oriented

Each prototype is structured like documentation that could move into a real product workflow.

NovaFlow

Enterprise workflow platform for connected teams.

Fictional SaaS product

Product concept

NovaFlow helps operations teams design workflows, connect tools, manage access, automate repetitive processes, and surface knowledge through AI-assisted search.

Primary audiences

Workspace admins Operations teams Developers End users Product teams

Core terminology

Workspace Workflow Trigger Action Connector Role

Explore the documentation system

Each prototype demonstrates a different documentation challenge, audience, and content pattern within one coherent product ecosystem.

11 prototype modules
01

Getting Started

Set up a workspace and reach the first successful workflow with minimal friction.

02

Feature Documentation

Explain a complex workflow automation feature through concepts, use cases, and configuration steps.

03

API Quickstart

Authenticate, send the first request, read the response, and handle an initial error.

04

API Reference

Define endpoints, parameters, request schemas, response objects, and error behavior.

05

Integration Guide

Connect NovaFlow to an external service and validate the data flow end to end.

06

Onboarding Documentation

Move a new team from account creation to first value through staged guidance.

07

Troubleshooting Guide

Diagnose failures through symptoms, likely causes, checks, and resolution paths.

08

Release Notes

Translate product changes into user impact, required action, and upgrade context.

09

Migration Guide

Move safely between product or API versions with clear prerequisites and rollback logic.

10

Knowledge Base

Resolve a common user problem through a concise, searchable support article.

11

Administrator Manual

Configure roles, permissions, governance rules, and workspace-level controls.

The cards already contain anchor links for the future prototype sections. As each HTML block is added to the Selected Work page, these links will begin scrolling directly to the corresponding document.
NovaFlow Docs · Get started 7-minute setup

Build your first NovaFlow workflow.

Create a workspace, invite a teammate, connect an app, and publish a simple workflow. By the end of this guide, NovaFlow will automatically route every new support request to the right owner.

Before you begin

This guide uses a sample support workflow so you can learn the core NovaFlow model: a trigger detects an event, one or more actions process it, and a published workflow runs the sequence automatically.

Access required

You need permission to create workflows and connect apps in your workspace.

You will need

  • A NovaFlow account with an active workspace.
  • Access to a shared support inbox.
  • A project or task-management tool supported by NovaFlow.
  • One teammate to invite for the assignment step.

1. Create your workspace

A workspace contains your people, apps, workflows, permissions, and execution history. Use one workspace for a single team or operating environment.

01

Name the workspace

Choose a name that people can identify quickly, such as Customer Operations.

Workspace setup
Customer Operations
novaflow.app/customer-operations
Create workspace
02

Invite a teammate

Open Workspace settings → Members, enter the teammate’s email address, and assign the Member role. Members can use published workflows but cannot change workspace-wide security settings.

2. Connect the apps

Connect the source app that creates the event and the destination app that receives the task. NovaFlow stores each connection at workspace level so approved workflows can reuse it.

01

Connect the shared inbox

Go to Connections, select your email provider, and authorize access to the shared support inbox. Choose the minimum permissions required to read new messages.

02

Connect the task tool

Add the project where support requests should become tasks. Confirm that NovaFlow can create tasks and assign them to members.

Security principle

Use least-privilege access. Do not grant write permissions to an app unless the workflow needs them.

3. Build the workflow

Create a workflow with one trigger and three actions. The trigger watches for a new email, while the actions classify the request, create a task, and assign an owner.

01

Add the trigger

Select New email received. Set the inbox to support@company.com and limit the trigger to unread messages.

02

Add the actions

  1. Classify request by billing, technical, or account topic.
  2. Create task with the email subject as the task title.
  3. Assign owner based on the classification result.
workflow.yaml Example
name: Route support requests
trigger:
  type: email.received
  inbox: support@company.com

actions:
  - type: ai.classify
    labels: [billing, technical, account]

  - type: task.create
    title: "{{ email.subject }}"

  - type: task.assign
    rule: "{{ classification.label }}"

4. Test before publishing

Run the workflow with sample data before allowing it to process live messages. NovaFlow shows the input, output, and status for every step.

01

Send a test message

Send an email with the subject Cannot update payment method. The classifier should identify it as a billing request.

02

Review the run

Confirm that every step shows Successful, the task contains the correct subject, and the billing owner is assigned.

The trigger received the correct inbox event.
The request was classified as billing.
The destination task was created once.
The correct owner received the assignment.

5. Publish and monitor

Select Publish workflow, review the permissions summary, and confirm. NovaFlow begins listening for new inbox events immediately.

After publishing

Open Runs to review execution history, duration, failed steps, and retried actions. Pause the workflow before changing a live connection or assignment rule.

You are ready

You have created a working NovaFlow automation and used the four core concepts: workspace, connection, trigger, and action.

NovaFlow Docs · Product guide Feature documentation

Build reliable logic with conditional branches.

Use conditional branches to route workflow runs through different paths based on field values, classification results, user attributes, or external data. This guide explains the feature model, configuration options, validation rules, edge cases, and implementation patterns.

What conditional branches do

A conditional branch evaluates one or more rules during a workflow run and selects the first matching path. Each path can contain its own actions, approvals, notifications, or nested logic.

IF

Condition

A rule that compares runtime data with a value, set, pattern, or expression.

BR

Branch

A named execution path that runs only when its condition evaluates to true.

EL

Fallback

An optional default path that runs when no explicit condition matches.

Evaluation model

Branches are evaluated from top to bottom. NovaFlow runs the first matching branch and skips the rest.

When to use this feature

Conditional branches are best for decisions with clear, stable rules and distinct outcomes.

Use case Input Example branches Business outcome
Support routing Request category Billing / Technical / Account Assign the correct team automatically
Approval control Purchase amount Under 5k / 5k–25k / Above 25k Apply the correct approval chain
Risk handling Risk score Low / Medium / High Escalate higher-risk records
Customer experience Plan type Starter / Growth / Enterprise Tailor onboarding and notifications
Do not use branches for every variation

If many branches differ only by a value, use a lookup table or reusable mapping instead. Excessive branching makes workflows harder to test and maintain.

How branch evaluation works

NovaFlow resolves the input, evaluates the branches in order, runs the first true branch, and records the decision in the workflow history.

Step 1 Resolve input Read runtime field values and prior action outputs.
Step 2 Evaluate Test the first condition using the selected operator.
Step 3 Select path Choose the first branch that evaluates to true.
Step 4 Execute Run only the actions contained in the selected branch.
Step 5 Record result Store the decision, inputs, and branch output in history.

Configure a conditional branch

This example routes purchase requests by amount and applies a different approval path to each spending tier.

1. Add a branch step

In the workflow builder, select Logic → Conditional branch. Choose the purchase amount from the trigger payload as the input field.

Conditional branch Purchase approval workflow
Branch 1 Standard approval amount is less than 5000
OR
Branch 2 Finance review amount is between 5000 and 25000

2. Add the high-value branch

Create a third branch for amounts above 25,000 and route it to Finance plus the executive approver.

3. Add a fallback

Use the fallback branch for missing, invalid, or unexpected values. Do not silently continue when a required decision input is unavailable.

YAML configuration example

NovaFlow stores feature configuration as structured workflow definitions. The following example mirrors the purchase approval branch created in the visual builder.

workflow.yaml Conditional branch
name: Purchase approval routing

trigger:
  type: purchase.requested

steps:
  - id: approval_path
    type: conditional
    input: "{{ trigger.amount }}"

    branches:
      - name: standard_approval
        when:
          operator: less_than
          value: 5000
        run:
          - type: approval.request
            approver: team_manager

      - name: finance_review
        when:
          operator: between
          min: 5000
          max: 25000
        run:
          - type: approval.request
            approver: finance_team

      - name: executive_review
        when:
          operator: greater_than
          value: 25000
        run:
          - type: approval.request
            approver: finance_team
          - type: approval.request
            approver: executive_sponsor

    fallback:
      - type: workflow.fail
        message: "Purchase amount is missing or invalid."

JSON payload example

The branch input may come from a trigger, API request, form submission, or previous workflow action.

purchase-request.json Runtime payload
{
  "event": "purchase.requested",
  "request_id": "pr_8F42A1",
  "amount": 18450,
  "currency": "USD",
  "requester": {
    "user_id": "usr_2841",
    "department": "Marketing"
  },
  "metadata": {
    "cost_center": "MKT-410",
    "vendor_status": "approved"
  }
}
Expected result

The amount 18,450 matches the finance_review branch and skips the other paths.

Markdown-style authoring pattern

Feature documentation should explain concepts, behavior, configuration, and consequences—not just list controls. The following pattern is suitable for a production Markdown source file.

## Configure a fallback branch

Add a fallback branch when the workflow may receive missing, invalid, or unexpected values. A fallback prevents the run from continuing with an undefined decision.

Use: fallback for values that do not match any explicit condition.

Avoid: routing unknown values into the lowest-risk branch without review.

Tip: Send fallback runs to a monitored queue so an operator can inspect the input and update the rule safely.

Supported operators

Operator Supported types Behavior Example
equals String, number, boolean Matches an exact normalized value plan equals enterprise
contains String, array Checks whether a value or member is present tags contains urgent
between Number, date Matches an inclusive lower and upper bound amount between 5000 and 25000
matches String Evaluates a regular expression pattern email matches company domain
is_empty String, array, object Matches null, absent, or empty values cost_center is empty

Edge cases and limits

Overlapping conditions

When two branches can match the same input, only the first branch runs. Reorder branches or make the conditions mutually exclusive.

Missing values

A missing field does not equal zero, false, or an empty string. Use an explicit is_empty condition or fallback branch.

  • Each conditional step supports up to 20 branches.
  • Nested branches are supported up to five levels.
  • Regular expressions must complete within the platform execution limit.
  • Branch names must be unique within the same conditional step.
  • Changing branch order affects future runs but does not modify historical results.

Test and validate branch logic

Test each branch independently, then test ambiguous, missing, and boundary values.

Use one test input for every explicit branch.
Test exact boundaries such as 5000 and 25000.
Test missing, null, and malformed values.
Confirm only one branch runs for each input.
Review actions and permissions inside every branch.
Verify the fallback creates a visible, actionable result.

Best practices

  1. Name branches by outcome. Use Finance review, not Branch 2.
  2. Keep conditions mutually exclusive. Avoid relying on order to resolve ambiguity.
  3. Use a fallback. Unknown values should create a visible exception path.
  4. Separate business rules from credentials. Branch logic should not contain secrets.
  5. Document ownership. Identify who approves rule changes and who handles failures.
  6. Test before publishing. Validate every branch and every boundary value.
NovaFlow Administrator Manual
NovaFlow Docs · AdministrationEnterprise administrator manual

Govern NovaFlow with control and confidence.

Configure identity, access, integrations, workflow governance, auditability, retention, and recovery across your organization. This manual is written for workspace administrators, platform owners, security teams, and operations leaders.

Administration overview

Administrators maintain the operating environment in which NovaFlow workflows are created, published, monitored, and retired. Administrative decisions affect every user, connection, and automated process in the workspace.

ID

Identity

Control authentication, provisioning, sessions, domains, and privileged access.

GV

Governance

Define ownership, approvals, naming, lifecycle, and publishing requirements.

AU

Auditability

Monitor security events, configuration changes, and workflow activity.

Use least privilege by default

Grant only the permissions required for a person’s current responsibilities. Review privileged access on a fixed cadence.

Configure workspace settings

Set durable organization-level defaults before inviting large user groups or connecting production systems.

SettingRecommended valueWhy it matters
Workspace nameDurable business or platform nameAvoid temporary project names that lose meaning
Primary domainVerified corporate domainSupports trusted provisioning and domain controls
Default time zoneOperational reporting time zoneKeeps schedules, logs, and reviews consistent
Default languagePrimary operating languageStandardizes notifications and system guidance
Data regionApproved residency regionAligns storage with legal and policy requirements

Manage users, roles, and permissions

Separate workspace administration, workflow publishing, workflow building, daily use, and auditing into distinct permission profiles.

RoleBuild workflowsPublishManage integrationsManage accessView audit logs
Workspace AdminYesYesYesYesYes
Workflow ManagerYesYesApproved onlyNoLimited
BuilderYesBy approvalNoNoNo
MemberNoNoNoNoNo
AuditorNoNoNoNoRead only
Maintain two administrators

Keep at least two active workspace administrators to prevent lockout and ownership gaps.

Configure identity and access

Enterprise workspaces should centralize authentication and lifecycle management through SSO and directory provisioning.

SSO

SAML SSO

Authenticate through the organization’s identity provider.

SC

SCIM

Provision, update, and deactivate users automatically.

MFA

MFA

Require an additional verification factor for privileged users.

sso-config.yamlIdentity policy
identity:
  sso:
    protocol: saml_2_0
    enforced: true
    jit_provisioning: false

  mfa:
    required_for:
      - workspace_admin
      - workflow_manager

  sessions:
    maximum_duration_hours: 12
    idle_timeout_minutes: 30

  domains:
    verified:
      - company.com

Govern integrations and credentials

Every production connection should have an approved owner, documented scopes, a rotation plan, and a defined fallback when access fails.

Approve connectors before they become available to builders.
Use service accounts for business-critical automations.
Grant only the OAuth scopes required by the workflow.
Document credential owners and rotation dates.
Separate sandbox and production credentials.
Revoke unused or orphaned connections immediately.

Apply workflow governance

Standardize how workflows are named, reviewed, published, changed, monitored, deprecated, and archived.

workspace-policy.yamlGovernance policy
workspace_policy:
  require_mfa_for_admins: true
  publish_approval_required: true
  minimum_publish_approvers: 1
  require_named_owner: true
  require_rollback_notes: true

  naming:
    pattern: "{team}-{process}-{environment}"

  audit:
    retention_days: 365

  connections:
    allow_personal_accounts: false

Monitor audit logs

Audit logs record security-sensitive and administrative actions. Export them to the organization’s monitoring or SIEM platform when centralized retention is required.

audit-event.jsonRole update event
{
  "event": "role.updated",
  "event_id": "evt_9F21C4",
  "actor": {
    "user_id": "usr_2841",
    "role": "workspace_admin"
  },
  "target": {
    "user_id": "usr_3920",
    "previous_role": "member",
    "new_role": "workflow_manager"
  },
  "source_ip": "203.0.113.42",
  "timestamp": "2026-07-23T00:42:18Z"
}
Event categoryExamplesRecommended alert
IdentitySSO disabled, admin MFA changedImmediate
AccessAdmin assigned, role elevatedImmediate
IntegrationConnection created, scope changedHigh priority
WorkflowPublished, disabled, ownership changedDaily review
DataExport requested, retention changedImmediate

Manage data and retention

Classify the data processed by each workflow and apply retention, export, deletion, and access rules that match organizational policy.

CL

Classify

Identify personal, financial, confidential, and regulated data.

RT

Retain

Set limits for run history, logs, attachments, and exports.

DL

Delete

Define deletion ownership, evidence, exceptions, and legal holds.

Respond to incidents and recover safely

Use a controlled response sequence when a credential is compromised, a workflow creates harmful output, or a critical connection fails.

Step 1ContainPause the workflow or disable the affected connection.
Step 2Preserve evidenceRecord run IDs, timestamps, actors, inputs, and outputs.
Step 3CorrectRotate credentials, repair logic, or restore the approved version.
Step 4ValidateTest in sandbox before resuming production execution.
Emergency stop

Pause the workflow before editing live logic. Do not attempt to correct a harmful production run while new events continue entering the workflow.

Offboard users and transfer ownership

When a user leaves or changes roles, remove access, transfer owned assets, rotate affected credentials, and verify that no critical workflow depends on a personal account.

Deactivate the user through SCIM or the admin console.
Transfer owned workflows and connections.
Revoke personal tokens and active sessions.
Rotate shared secrets the user could access.
Review recent privileged actions in the audit log.
Confirm a new operational owner is documented.

Administrator review cadence

CadenceReviewOwner
WeeklyFailed runs, expiring credentials, unresolved incidentsPlatform operations
MonthlyUnused connections, orphaned workflows, publish activityWorkspace admin
QuarterlyPrivileged roles, access recertification, policy exceptionsSecurity and compliance
AnnuallyRetention, recovery procedures, workspace architecturePlatform owner
Administration is continuous

A secure workspace is maintained through recurring review, not a one-time configuration project.

NovaFlow Administrator Manual
NovaFlow Docs · AdministrationEnterprise administrator manual

Govern NovaFlow with control and confidence.

Configure identity, access, integrations, workflow governance, auditability, retention, and recovery across your organization. This manual is written for workspace administrators, platform owners, security teams, and operations leaders.

Administration overview

Administrators maintain the operating environment in which NovaFlow workflows are created, published, monitored, and retired. Administrative decisions affect every user, connection, and automated process in the workspace.

ID

Identity

Control authentication, provisioning, sessions, domains, and privileged access.

GV

Governance

Define ownership, approvals, naming, lifecycle, and publishing requirements.

AU

Auditability

Monitor security events, configuration changes, and workflow activity.

Use least privilege by default

Grant only the permissions required for a person’s current responsibilities. Review privileged access on a fixed cadence.

Configure workspace settings

Set durable organization-level defaults before inviting large user groups or connecting production systems.

SettingRecommended valueWhy it matters
Workspace nameDurable business or platform nameAvoid temporary project names that lose meaning
Primary domainVerified corporate domainSupports trusted provisioning and domain controls
Default time zoneOperational reporting time zoneKeeps schedules, logs, and reviews consistent
Default languagePrimary operating languageStandardizes notifications and system guidance
Data regionApproved residency regionAligns storage with legal and policy requirements

Manage users, roles, and permissions

Separate workspace administration, workflow publishing, workflow building, daily use, and auditing into distinct permission profiles.

RoleBuild workflowsPublishManage integrationsManage accessView audit logs
Workspace AdminYesYesYesYesYes
Workflow ManagerYesYesApproved onlyNoLimited
BuilderYesBy approvalNoNoNo
MemberNoNoNoNoNo
AuditorNoNoNoNoRead only
Maintain two administrators

Keep at least two am-active workspace administrators to prevent lockout and ownership gaps.

Configure identity and access

Enterprise workspaces should centralize authentication and lifecycle management through SSO and directory provisioning.

SSO

SAML SSO

Authenticate through the organization’s identity provider.

SC

SCIM

Provision, update, and deactivate users automatically.

MFA

MFA

Require an additional verification factor for privileged users.

sso-config.yamlIdentity policy
identity:
  sso:
    protocol: saml_2_0
    enforced: true
    jit_provisioning: false

  mfa:
    required_for:
      - workspace_admin
      - workflow_manager

  sessions:
    maximum_duration_hours: 12
    idle_timeout_minutes: 30

  domains:
    verified:
      - company.com

Govern integrations and credentials

Every production connection should have an approved owner, documented scopes, a rotation plan, and a defined fallback when access fails.

Approve connectors before they become available to builders.
Use service accounts for business-critical automations.
Grant only the OAuth scopes required by the workflow.
Document credential owners and rotation dates.
Separate sandbox and production credentials.
Revoke unused or orphaned connections immediately.

Apply workflow governance

Standardize how workflows are named, reviewed, published, changed, monitored, deprecated, and archived.

workspace-policy.yamlGovernance policy
workspace_policy:
  require_mfa_for_admins: true
  publish_approval_required: true
  minimum_publish_approvers: 1
  require_named_owner: true
  require_rollback_notes: true

  naming:
    pattern: "{team}-{process}-{environment}"

  audit:
    retention_days: 365

  connections:
    allow_personal_accounts: false

Monitor audit logs

Audit logs record security-sensitive and administrative actions. Export them to the organization’s monitoring or SIEM platform when centralized retention is required.

audit-event.jsonRole update event
{
  "event": "role.updated",
  "event_id": "evt_9F21C4",
  "actor": {
    "user_id": "usr_2841",
    "role": "workspace_admin"
  },
  "target": {
    "user_id": "usr_3920",
    "previous_role": "member",
    "new_role": "workflow_manager"
  },
  "source_ip": "203.0.113.42",
  "timestamp": "2026-07-23T00:42:18Z"
}
Event categoryExamplesRecommended alert
IdentitySSO disabled, admin MFA changedImmediate
AccessAdmin assigned, role elevatedImmediate
IntegrationConnection created, scope changedHigh priority
WorkflowPublished, disabled, ownership changedDaily review
DataExport requested, retention changedImmediate

Manage data and retention

Classify the data processed by each workflow and apply retention, export, deletion, and access rules that match organizational policy.

CL

Classify

Identify personal, financial, confidential, and regulated data.

RT

Retain

Set limits for run history, logs, attachments, and exports.

DL

Delete

Define deletion ownership, evidence, exceptions, and legal holds.

Respond to incidents and recover safely

Use a controlled response sequence when a credential is compromised, a workflow creates harmful output, or a critical connection fails.

Step 1ContainPause the workflow or disable the affected connection.
Step 2Preserve evidenceRecord run IDs, timestamps, actors, inputs, and outputs.
Step 3CorrectRotate credentials, repair logic, or restore the approved version.
Step 4ValidateTest in sandbox before resuming production execution.
Emergency stop

Pause the workflow before editing live logic. Do not attempt to correct a harmful production run while new events continue entering the workflow.

Offboard users and transfer ownership

When a user leaves or changes roles, remove access, transfer owned assets, rotate affected credentials, and verify that no critical workflow depends on a personal account.

Deactivate the user through SCIM or the admin console.
Transfer owned workflows and connections.
Revoke personal tokens and am-active sessions.
Rotate shared secrets the user could access.
Review recent privileged actions in the audit log.
Confirm a new operational owner is documented.

Administrator review cadence

CadenceReviewOwner
WeeklyFailed runs, expiring credentials, unresolved incidentsPlatform operations
MonthlyUnused connections, orphaned workflows, publish activityWorkspace admin
QuarterlyPrivileged roles, access recertification, policy exceptionsSecurity and compliance
AnnuallyRetention, recovery procedures, workspace architecturePlatform owner
Administration is continuous

A secure workspace is maintained through recurring review, not a one-time configuration project.

NovaFlow API Reference — ScriptWise Portfolio
NovaFlow Developer PlatformScriptWise documentation portfolio
REST API v1 · Stable
API Reference · Complete Technical Specification

Every resource, field, and response — precisely documented.

Use this reference to build, validate, and operate NovaFlow integrations. Each ar-endpoint follows a consistent contract: required scope, parameters, request schema, response schema, examples, and predictable error behavior.

Reference overview

API conventions

NovaFlow exposes a versioned REST API over HTTPS. Requests and responses use JSON, resource identifiers are stable, timestamps use ISO 8601 in UTC, and all authenticated operations are scoped to a workspace.

Base URLapi.novaflow.dev

All production requests use HTTPS.

Version/v1

Major ar-version is encoded in the path.

Media typeapplication/json

JSON request and response bodies.

Time formatISO 8601 UTC

Example: 2026-07-23T09:42:18Z.

Authentication headers

Required headersHTTP
Authorization: Bearer nf_live_••••••••
NovaFlow-Workspace: ws_01J9KX2A8Q
Content-Type: application/json
Workspace context is explicit

Tokens can be authorized for multiple workspaces. The NovaFlow-Workspace header makes tenant selection deterministic and auditable.

Resource group · Workflows

Workflow endpoints

Workflows define automation logic, triggers, and lifecycle state. Draft workflows can be edited; published workflows can be executed; archived workflows remain retrievable for audit purposes.

POST/v1/workflows
Scope: workflows:write

Create a workflow

Creates a draft workflow in the selected workspace. Use an idempotency key when the client may retry the request.

FieldTypeRequirementDescription
namestringRequiredHuman-readable workflow name. Maximum 120 characters.
environmentenumRequiredsandbox or production.
triggerobjectRequiredInitial workflow trigger configuration.
descriptionstringOptionalInternal summary. Maximum 500 characters.
tagsarray<string>OptionalUp to 20 searchable labels.
RequestcURL
curl --request POST \
  "https://api.novaflow.dev/v1/workflows" \
  --header "Authorization: Bearer $NOVAFLOW_API_KEY" \
  --header "NovaFlow-Workspace: $WORKSPACE_ID" \
  --header "Idempotency-Key: wf-create-001" \
  --data '{"name":"Purchase approval","environment":"sandbox","trigger":{"type":"manual"}}'
201 CreatedJSON
{
  "id": "wf_01JA2Z8P4N",
  "object": "workflow",
  "name": "Purchase approval",
  "status": "draft",
  "environment": "sandbox",
  "ar-version": 1
}
GET/v1/workflows
Scope: workflows:read

List workflows

Returns a cursor-paginated collection with filtering by status, environment, and sort order.

GET/v1/workflows/{workflow_id}
Scope: workflows:read

Retrieve a workflow

Returns the latest representation of a workflow, including lifecycle state and ar-active version.

PATCH/v1/workflows/{workflow_id}
Scope: workflows:write

Update a workflow

Applies a partial update to a draft workflow. Published versions are immutable.

POST/v1/workflows/{workflow_id}/publish
Scope: workflows:publish

Publish a workflow

Validates the draft and creates an immutable published version.

DELETE/v1/workflows/{workflow_id}
Scope: workflows:write

Archive a workflow

Moves the workflow to an archived state while preserving audit visibility.

Resource group · Workflow runs

Workflow run endpoints

Runs represent individual workflow executions and expose execution state, timing, input, output, and failure metadata.

POST/v1/workflows/{workflow_id}/runs
Scope: runs:write

Start a workflow run

Starts an execution of a published workflow and returns a queued run resource.

GET/v1/runs/{run_id}
Scope: runs:read

Retrieve run status

Returns queued, running, succeeded, failed, or canceled.

GET/v1/runs
Scope: runs:read

List workflow runs

Filters by workflow, status, environment, correlation ID, and time range.

POST/v1/runs/{run_id}/cancel
Scope: runs:write

Cancel a workflow run

Requests cancellation of a queued or running execution.

Resource group · Webhooks

Webhook endpoints

Webhooks deliver signed event notifications to external systems. Every delivery includes a stable event ID, timestamp, and HMAC SHA-256 signature.

POST/v1/webhook-endpoints
Scope: webhooks:write

Create a webhook endpoint

Registers an HTTPS ar-endpoint and one or more event subscriptions.

The signing secret is shown once

Store it immediately in a secrets manager. NovaFlow cannot reveal the original value after creation.

GET/v1/webhook-endpoints
Scope: webhooks:read

List webhook endpoints

Returns ar-endpoint status, subscriptions, and delivery metadata.

POST/v1/webhook-endpoints/{endpoint_id}/rotate-secret
Scope: webhooks:write

Rotate a signing secret

Generates a replacement secret with a short overlap window.

DELETE/v1/webhook-endpoints/{endpoint_id}
Scope: webhooks:write

Delete a webhook endpoint

Stops future deliveries and removes the configuration.

Errors, pagination, and limits

Shared API behavior

All errors use one structured envelope. Clients should make retry decisions from the HTTP status and machine-readable code, not by parsing human-readable messages.

Example errorJSON
{
  "error": {
    "type": "validation_error",
    "code": "invalid_trigger_configuration",
    "message": "The trigger configuration is incomplete.",
    "request_id": "req_01JA30K6FQ",
    "documentation_url": "/docs/errors/invalid-trigger-configuration"
  }
}
StatusCategoryRetry?Client behavior
400Malformed requestNoCorrect request syntax or payload.
401AuthenticationNoReplace or correct credentials.
403AuthorizationNoReview scopes or workspace access.
409ConflictConditionalRead current state before deciding.
429Rate limitYesHonor Retry-After and back off.
5xxService failureYesRetry with bounded exponential backoff and jitter.
Default workspace limit: 1,200 requests per minute.
Cursors are opaque and must not be parsed or modified.
Use response headers to adapt before requests are rejected.
Keep filters and sort order stable across paginated requests.
Reference design principle

Every ar-endpoint follows the same order: purpose, authorization, inputs, schema, examples, success response, and error behavior.

Continue learning

Move from reference to implementation

Use the Integration Guide when you need to connect NovaFlow to a real external system, map data, test failure modes, and plan rollout ownership.

NovaFlow Integration Guide — ScriptWise Portfolio
NovaFlow Developer PlatformScriptWise documentation portfolio
Integration pattern · Enterprise
Integration Guide · Enterprise Implementation

Connect NovaFlow to your stack — safely, predictably, and at scale.

This guide documents the complete implementation path for connecting a CRM or ERP system to NovaFlow, transforming business data, triggering workflows, handling asynchronous events, and operating the integration in production.

Implementation overview

Define the integration boundary before writing code

The reference implementation receives purchase requests from a CRM, transforms them into NovaFlow workflow inputs, executes an approval workflow, sends approved records to an ERP, and publishes operational events to Slack and analytics.

System of record

CRM

Owns the original customer and purchase-request data.

Orchestration

NovaFlow

Validates, routes, approves, and records each workflow execution.

Downstream system

ERP

Receives approved financial records and creates the purchase order.

Operational channels

Slack + Analytics

Receive notifications and execution telemetry without becoming systems of record.

Integration principle

Assign one authoritative owner to every business field and lifecycle state. NovaFlow orchestrates the process; it does not silently replace the CRM or ERP as the system of record.

Architecture

Recommended enterprise topology

Place an integration service between internal systems and NovaFlow. The service owns authentication, transformation, correlation IDs, retry policy, and deployment lifecycle.

SourceCRM / ERP
BoundaryIntegration Service
OrchestrationNovaFlow API
ERP write-back
Slack notification
Analytics event
Audit archive

Choose the interaction model

PatternUse whenTrade-off
Synchronous APIThe caller needs immediate validation or a resource ID.Tightly coupled to request latency and availability.
Asynchronous runThe workflow may take seconds or minutes.Requires status polling or ig-event handling.
WebhookThe client should react to state changes without polling.Requires signature validation and delivery recovery.
QueueTraffic spikes, ordering, or backpressure must be absorbed.Adds operational complexity and eventual consistency.

Authentication and authorization flow

01Load secret
02Authenticate
03Select workspace
04Check scope
05Execute request
06Record request ID
Data contract

Map source fields explicitly

Document every transformation before implementation. The mapping should identify the source owner, target path, type conversion, validation rule, and behavior when a value is missing.

CRM fieldNovaFlow fieldTransformValidationOwner
purchaseRequestIdinput.request_idString, unchangedRequired; unique per CRMCRM
customerIdinput.customer.idString, unchangedRequiredCRM
customerNameinput.customer.nameTrim whitespace1–160 charactersCRM
amountinput.purchase.amount_minorDecimal × 100Positive integerCRM
currencyinput.purchase.currencyUppercase ISO codeThree charactersCRM
createdAtinput.source.created_atConvert to UTCISO 8601CRM

Canonical payload

workflow-input.jsonJSON
{
  "request_id": "PR-2026-1048",
  "customer": {"id": "CUS-80341", "name": "Northstar Medical Group"},
  "purchase": {"amount_minor": 248500, "currency": "EUR"},
  "source": {"system": "crm", "created_at": "2026-07-23T08:55:00Z"}
}
Reject ambiguous mappings

Do not guess currency, timezone, ownership, or identifier semantics. Treat unresolved mappings as design issues, not implementation details.

Request lifecycle

Trace one transaction end to end

01Receive
02Validate
03Transform
04Execute
05Persist
06Notify

Start the workflow run

POST /v1/workflows/{workflow_id}/runscURL
curl --request POST   "https://api.novaflow.dev/v1/workflows/wf_purchase_approval/runs"   --header "Authorization: Bearer $NOVAFLOW_API_KEY"   --header "NovaFlow-Workspace: $WORKSPACE_ID"   --header "Idempotency-Key: PR-2026-1048"   --data '{"correlation_id":"PR-2026-1048","input":{"request_id":"PR-2026-1048"}}'
Correlation is mandatory

Use the same business correlation ID across CRM logs, NovaFlow runs, ERP records, webhook events, and support tickets.

Reliability engineering

Design for partial failure

Distributed integrations fail in fragments. The client may time out after NovaFlow accepted a request, a webhook may arrive twice, or the ERP may be unavailable after approval succeeds.

Duplicate request

Idempotency key

Reuse the source business ID so retried create or execute operations return the original result.

Temporary failure

Bounded retries

Retry 429 and selected 5xx responses with exponential backoff and jitter.

Repeated event

Event deduplication

Persist the webhook ig-event ID before applying downstream side effects.

Persistent failure

Dead-letter handling

Move exhausted messages to a review queue with payload, attempts, and last error.

Retry decision matrix

FailureRetry?Action
400 validation errorNoCorrect the source data or mapping.
401 invalid credentialNoRotate or replace the credential.
409 state conflictConditionalRead current state before deciding.
429 rate limitYesHonor Retry-After and add jitter.
502 / 503 / 504YesRetry a bounded number of times.
Webhook timeoutHandled by NovaFlowReturn 2xx only after durable acceptance.

Webhook signature verification

verify-webhook.jsNode.js
const signedPayload = `${timestamp}.${rawBody}`;
const expected = createHmac("sha256", webhookSecret)
  .update(signedPayload).digest("hex");

if (!timingSafeEqual(Buffer.from(expected), Buffer.from(signature))) {
  throw new Error("Invalid webhook signature");
}
Security controls

Protect credentials, data, and administrative actions

Store API keys and webhook secrets in a managed secrets service.
Grant separate read, write, publish, and webhook scopes.
Use different credentials for development, staging, and production.
Redact credentials, personal data, and full payloads from logs.
Rotate secrets through an overlap window to avoid downtime.
Audit configuration changes and production access.
Least privilege is an integration requirement

Do not issue one all-powerful token for every environment and service. Scope credentials to one workload, one environment, and the minimum required operations.

Testing and rollout

Prove the contract before production

Test layerPurposeExample
Schema validationCatch malformed source data before API calls.Reject missing currency or invalid timestamps.
Contract testVerify request and response compatibility.Assert required fields and stable error codes.
Sandbox integrationValidate real authentication and resource behavior.Create and execute a non-production workflow.
Failure injectionProve retry, deduplication, and recovery logic.Simulate 429, timeout, duplicate webhook, ERP outage.
Load testMeasure throughput and backpressure behavior.Replay peak-hour traffic with realistic payload sizes.

Deployment sequence

Stage 01Development

Local mocks and schema validation.

Stage 02Sandbox

Real NovaFlow API and test credentials.

Stage 03Staging

Production-like data volume and dependencies.

Stage 04Canary

Limited production traffic with rollback controls.

Release readiness checklist

Data ownership and field mappings are approved.
Credentials, scopes, and rotation owners are documented.
Retry and dead-letter behavior is tested.
Dashboards and alerts exist before go-live.
Rollback and replay procedures are documented.
Support teams know the correlation and request IDs to collect.
Operations

Monitor the integration as a business process

SignalWhy it mattersSuggested alert
Request ig-success rateDetects broad API or client failures.Below 99.5% for 10 minutes.
End-to-end latencyMeasures business completion, not only API response time.P95 above agreed service objective.
Retry volumeReveals degraded dependencies before hard failure.Threefold increase over baseline.
Webhook delivery failuresDetects broken ig-event consumption.Any sustained failure after automatic retries.
Dead-letter queue depthShows unresolved business transactions.Above zero beyond the response window.
Mapping rejection rateIdentifies source-data quality regression.Above 1% of incoming records.

Troubleshooting matrix

SymptomLikely causeDiagnosisResolution
401 responsesExpired or wrong-environment tokenCheck token prefix and audit logs.Rotate the correct credential.
Duplicate ERP recordsMissing idempotency or ig-event deduplicationCompare correlation and ig-event IDs.Persist processed IDs and replay safely.
Runs remain queuedCapacity or workflow dependency issueInspect run status and platform notices.Pause intake or apply backpressure.
Webhook signature failsRaw body changed or secret mismatchCompare timestamp, raw bytes, and ig-active secret.Use the unmodified body and current secret.
Continue learning

Move from implementation to operations

Continue with Troubleshooting for symptom-based recovery procedures, or return to API Reference for exact endpoint contracts.

NovaFlow Troubleshooting Guide — ScriptWise Portfolio
Troubleshooting · Production Operations

Diagnose failures with evidence, not guesswork.

Use this guide to isolate failed requests, delayed workflow runs, webhook delivery issues, integration errors, and configuration problems across the NovaFlow platform.

Diagnostic method

Start with the transaction, not the symptom

A visible symptom may appear far from the original failure. A missing Slack notification can begin with invalid CRM data. A timed-out API call can still create a successful workflow run. A duplicated ERP record can result from retrying without an idempotency key.

Troubleshoot one business transaction end to end. Identify where the transaction entered NovaFlow, how it was validated, which workflow state it reached, and whether downstream side effects completed.

01Identify
02Locate
03Classify
04Recover
05Verify
Use the same correlation ID everywhere

The business correlation ID should connect source-system logs, the NovaFlow run, webhook events, downstream records, monitoring traces, and the support case.

Evidence collection

Build the diagnostic package first

Collect the following information before retrying, editing configuration, or escalating. This preserves the original evidence and reduces repeated questions between engineering, operations, and support.

Request ID from the NovaFlow response headers or error payload.
Correlation ID from the source business transaction.
Workspace and environment, including region when applicable.
UTC timestamp and the approximate duration of the issue.
Endpoint, workflow, or connector involved in the transaction.
HTTP ts-status and error code, with secrets and personal data removed.
Expected result and the actual observed result.
Last known successful step in the transaction lifecycle.
diagnostic-package.jsonJSON
{
  "workspace_id": "ws_prod_eu_01",
  "environment": "production",
  "request_id": "req_01JZ91D8R7X4",
  "correlation_id": "PR-2026-1048",
  "workflow_id": "wf_purchase_approval",
  "run_id": "run_01JZ91F2H6M3",
  "observed_at": "2026-07-23T11:42:18Z",
  "ts-status": "waiting_for_connector",
  "last_successful_step": "manager_approval"
}
Triage

Classify the failure before choosing an action

Domain 01 Request and authentication

The API rejects the request before a workflow run starts.

  • 401 or 403 response
  • Invalid token or missing scope
  • Wrong workspace or environment
Domain 02 Validation and mapping

The request reaches NovaFlow but violates the data contract.

  • 400 or 422 response
  • Missing required field
  • Type, timezone, or currency mismatch
Domain 03 Workflow execution

The run starts but remains blocked, delayed, or failed.

  • Long-running step
  • Missing approval
  • Expression or configuration error
Domain 04 Connector and downstream system

NovaFlow completes an internal step but cannot deliver the side effect.

  • ERP or CRM unavailable
  • Expired connector credential
  • Rate limit or schema drift
Domain 05 Webhook delivery

The event exists, but the consumer does not accept or process it.

  • Non-2xx endpoint response
  • Signature mismatch
  • Duplicate or delayed event
Domain 06 Platform or regional service

Multiple unrelated transactions fail in the same period.

  • Broad increase in 5xx errors
  • Cross-workflow latency spike
  • Regional ts-status degradation
API failures

Interpret the response before retrying

ResponseMeaningCheckRecommended action
400 Bad RequestThe payload or request syntax is invalid.JSON structure, headers, field names, encoding.Correct the request. Do not retry unchanged.
401 UnauthorizedThe credential is missing, invalid, or expired.Bearer token, environment, secret rotation.Replace the credential, then send a new request.
403 ForbiddenThe credential is valid but lacks required access.Workspace, role, API scope, resource ownership.Grant the minimum required scope.
409 ConflictThe requested change conflicts with current state.Resource version, run status, duplicate operation.Read the current state before deciding whether to retry.
422 Validation ErrorThe payload is syntactically valid but violates the contract.Required fields, enums, formats, business rules.Correct the source data or mapping.
429 Rate LimitedThe client exceeded an allowed request rate.Retry-After, concurrency, burst volume.Back off with jitter and reduce concurrency.
502 / 503 / 504A service or dependency is temporarily unavailable.Request ID, ts-status page, retry history.Retry a bounded number of times using the same idempotency key.

Inspect the error object

validation-error.jsonHTTP 422
{
  "error": {
    "code": "invalid_field_value",
    "message": "purchase.currency must be a supported ISO 4217 code",
    "field": "input.purchase.currency",
    "request_id": "req_01JZ91D8R7X4",
    "documentation_url": "/api-reference/errors#invalid-field-value"
  }
}
Do not turn a permanent error into a retry storm

Authentication, authorization, validation, and mapping failures require correction. Automated retries are appropriate only for explicitly transient conditions.

Workflow execution

Diagnose a delayed or failed run

A workflow can remain ts-active while waiting for a human decision, scheduled time, connector response, queue capacity, or retry window. Confirm the current state before treating a long-running execution as a failure.

Run statusInterpretationFirst checkRecovery path
queuedThe run is accepted but has not started.Queue age and workspace concurrency.Wait within the expected window; investigate sustained backlog.
runningAt least one step is actively executing.Current step and elapsed time.Compare with the step timeout and dependency latency.
waiting_for_approvalThe run requires a human decision.Assigned approver and due date.Reassign or remind according to policy.
waiting_for_connectorA downstream dependency has not completed.Connector health, credential, and retry count.Restore the dependency, then retry or replay safely.
failedA terminal error stopped execution.Failed step, error code, preserved outputs.Correct the cause and resume or create a controlled replay.
completed_with_warningsThe main outcome completed but a noncritical action failed.Warning list and downstream side effect.Recover the failed side effect without rerunning completed work.

Retrieve the current run state

GET /v1/runs/{run_id}cURL
curl --request GET \
  "https://api.novaflow.dev/v1/runs/run_01JZ91F2H6M3" \
  --header "Authorization: Bearer $NOVAFLOW_API_KEY" \
  --header "NovaFlow-Workspace: $WORKSPACE_ID"
Recover the smallest failed unit

If the approval and ERP write already succeeded, retrying the entire workflow may create duplicates. Prefer step-level recovery, event replay, or a compensating action when supported.

Webhook delivery

Separate delivery failure from processing failure

NovaFlow considers a webhook delivered when the endpoint returns a successful response within the configured timeout. Your endpoint should durably accept the event before starting slow business processing.

Symptom

No event received

Confirm the endpoint URL, subscribed event type, environment, and delivery log.

Symptom

Repeated deliveries

Persist the event ID and make downstream side effects idempotent.

Symptom

Signature mismatch

Verify against the unmodified raw body, correct timestamp, and ts-active secret.

Symptom

Delivery succeeds, action missing

Trace the event through the consumer queue and downstream transaction logs.

Locate the event

Search by event ID, run ID, or correlation ID in the NovaFlow delivery history.

Inspect the attempt

Review response code, duration, destination, retry count, and the final delivery state.

Validate the signature path

Use the raw request body and compare the configured secret with the endpoint environment.

Confirm durable acceptance

Return 2xx only after the event has been stored or placed on a durable internal queue.

Replay once

After correction, replay the event and verify that deduplication prevents duplicate effects.

Connectors and downstream systems

Check ownership at the integration boundary

A connector error does not always originate in NovaFlow. Determine whether the failure belongs to credentials, connectivity, destination availability, destination permissions, rate limits, or a changed external schema.

SignalLikely causeEvidenceOwner
Credential rejectedExpired secret, revoked token, wrong tenant.Connector authentication log and rotation history.Integration owner
Connection timeoutNetwork path or downstream outage.Destination health, DNS, firewall, regional telemetry.Platform / network
Permission deniedDestination role no longer allows the operation.Destination audit log and assigned role.Destination administrator
Payload rejectedSchema drift or unsupported field value.Destination error payload and contract version.Application owner
Rate limitedConcurrency or request burst exceeds destination limit.429 response, quota dashboard, retry pattern.Integration owner
Partial writeDestination accepted some operations before failure.Destination transaction and object IDs.Joint investigation
Never rotate or replace a production credential without an owner

Credential changes can restore one workflow while breaking another. Confirm scope, environment, overlap window, dependent services, and rollback before rotation.

Recovery

Choose retry, replay, resume, or compensation

Recovery actionUse whenPrimary riskRequired control
Retry requestThe original request failed before any durable result.Duplicate creation after a client timeout.Reuse the original idempotency key.
Resume runThe run preserved completed steps and supports continuation.Resuming from an invalid state.Confirm the corrected dependency and current run state.
Replay eventThe event exists but downstream delivery or processing failed.Duplicate side effects.Deduplicate by event ID and business key.
Reprocess dead letterA queued transaction exhausted automatic attempts.Reintroducing unresolved ts-bad data.Approve the cause correction before reprocessing.
Compensating actionA completed side effect must be logically reversed.Incomplete business rollback.Use an auditable domain-specific compensation procedure.
Verification completes the recovery

A successful API response is not enough. Verify the expected business state in NovaFlow and every authoritative downstream system.

Escalation

Escalate with a reproducible case

Escalate when the issue affects multiple transactions, persists after a documented correction, indicates data loss or unauthorized access, or cannot be explained by the published contract and current system status.

Priority P1

Critical production impact

Security exposure, confirmed data loss, or a broad outage blocking a critical business process.

Priority P2

Major degraded operation

Repeated failures affecting multiple users or workflows with no practical workaround.

Priority P3

Limited functional issue

A contained failure with an available workaround and no integrity risk.

Priority P4

Question or documentation gap

Clarification, expected-behavior question, or improvement request without current service impact.

Include these fields in the support case

Business impact, number of affected transactions, and start time.
Workspace, environment, region, workflow ID, and connector name.
Request ID, run ID, event ID, and business correlation ID.
Sanitized request, response, error object, and relevant log extract.
Steps already attempted and the result of each action.
Whether the issue is reproducible in sandbox or staging.
Quick reference

Operational ts-decision checklist

Preserve evidence

Record identifiers and error data before changing configuration or replaying work.

Confirm scope

Determine whether one transaction, one workflow, one workspace, or the wider platform is affected.

Find the last successful boundary

Locate the exact point where expected state and observed state diverge.

Classify permanent versus transient

Correct permanent contract errors; apply bounded retries only to transient failures.

Recover safely

Use idempotency, deduplication, step-level recovery, or compensation as appropriate.

Verify the business result

Confirm final state across NovaFlow and every system of record.

Continue

Related NovaFlow documentation

NovaFlow Release Notes — ScriptWise Portfolio
Release Notes · Product Change Communication

Understand every change, before it reaches production.

These release notes explain what changed across the NovaFlow platform, who is affected, whether action is required, and how each update changes product behavior, API compatibility, and operational risk.

Release strategy

Release notes are part of the product contract

Release notes should help a customer decide what to do next. They are not a changelog dump and not a marketing recap. Each entry should identify the affected audience, explain the behavioral change, state compatibility impact, and make required action explicit.

NovaFlow publishes releases through a structured model that separates product capability, API behavior, operational impact, migration risk, and deprecation timing.

01Change
02Impact
03Action
04Validate
05Adopt
Release communication principle

If a customer cannot tell whether a change affects them, the release note is incomplete.

Release summary

NovaFlow 4.8 · July 2026

Availability

Production rollout complete

Released to all production workspaces between July 21 and July 23, 2026.

Compatibility

No breaking API changes

Existing v1 integrations continue to operate without request or response changes.

Required action

Review webhook consumers

Consumers using legacy run.finished events should begin migration planning.

Operational benefit

Safer recovery controls

Administrators can replay failed events from the delivery history with full audit traceability.

Recommended reading order

Review required actions first, then scan API, workflow, connector, and administrator changes relevant to your environment.

Required action

Complete these rn-checks before the rn-next release window

Inventory webhook consumers using the legacy run.finished event.
Confirm consumers can process the replacement run.completed and run.failed events.
Update operational runbooks to include manual event replay and replay audit history.
Verify monitoring rules distinguish delivery failure from downstream processing failure.
ActionOwnerDeadlineRisk if skipped
Assess legacy webhook usageIntegration ownerBefore September 15, 2026Missed events after deprecation removal.
Update internal runbookOperations leadBefore rn-next incident reviewSlower and less controlled recovery.
Validate replay deduplicationApplication ownerBefore enabling manual replay in productionDuplicate downstream side effects.
Product changes

New workflow and administrator capabilities

New

Manual event replay

Administrators can replay failed webhook deliveries directly from delivery history after correcting the destination issue.

Improved

Run detail timeline

The run page now separates workflow execution, connector delivery, retry attempts, and final recovery action.

Improved

Schema validation feedback

Validation errors now include the exact field path, rejected value type, and expected contract rule.

New

Connector health state

Connector rn-cards display current authentication state, last successful call, and recent error rate.

Manual event replay safeguards

Replay is permission-controlled and disabled for read-only roles.
The original event ID remains unchanged for deduplication.
Every replay records actor, timestamp, reason, and resulting delivery state.
Replay is unavailable while an automatic attempt is still active.
API and events

Compatibility-preserving API improvements

AreaChangeCompatibilityAction
Run retrievalGET /v1/runs/{run_id} now returns recovery_state.AdditiveNo action unless strict response validation is enabled.
Validation errorsError objects now include field and expected.AdditiveUpdate error rendering when useful.
Webhook deliveryDelivery attempts include replay_origin.AdditiveUse for audit and support context.
Event modelrun.finished is deprecated in favor of terminal-state events.DeprecationPlan migration before removal.

Updated run response

GET /v1/runs/run_01JZ91F2H6M3JSON
{
  "id": "run_01JZ91F2H6M3",
  "rn-status": "completed_with_warnings",
  "recovery_state": {
    "replay_available": true,
    "failed_event_count": 1,
    "last_recovery_action": null
  }
}
Strict schema consumers

Clients that reject unknown response properties should update their parsers before adopting this release.

Deprecations

Legacy run events enter a staged retirement period

The generic run.finished event remains available in this release but will be removed after the migration window. Use explicit terminal-state events to distinguish successful, failed, and warning-complete outcomes.

Deprecated itemReplacementDeprecatedRemoval target
run.finishedrun.completed, run.failed, run.completed_with_warningsJuly 23, 2026January 31, 2027
Do not wait until removal

Run both old and new event subscriptions in parallel, compare outcomes, and switch production consumers only after successful validation.

Resolved issues

Fixes included in NovaFlow 4.8

ReferenceIssueResolutionAffected area
NF-4821Webhook retry history could display attempts out of sequence after manual refresh.Attempts are now ordered by durable creation timestamp.Operations UI
NF-4873Connector health could remain degraded after successful credential rotation.Health state now recalculates after the first successful authenticated request.Connectors
NF-4902Validation errors for nested arrays omitted the array index.Field paths now include full indexed notation.API validation
NF-4938Run rn-timeline timestamps could appear in local browser time without a visible timezone label.All operational timestamps are now labeled and default to UTC.Run details
Known limitations

Known issues and current workarounds

Known issue

Large replay payload preview

Payloads above 500 KB may take several seconds to render in the browser. Download the sanitized payload instead.

Known issue

Connector health delay

Health rn-status may take up to two minutes to reflect a newly restored downstream dependency.

Workarounds are temporary documentation

Each workaround remains linked to a tracked engineering issue and should be removed when the product behavior is corrected.

Rollout and validation

How the release was deployed

Stage 01Internal

Production-like validation with NovaFlow operational teams.

Stage 02Early access

Selected workspaces validated replay and connector telemetry.

Stage 03Canary

Five percent of production workspaces received the release.

Stage 04General availability

Rollout completed after error and latency rn-checks remained within target.

Post-release validation

API rn-success rate remained above the release SLO.
Webhook retry volume remained within baseline variance.
No increase in duplicate downstream side effects was detected.
Connector authentication failures decreased after health-state improvements.
Audience guidance

What each audience should review

AudienceReview firstPrimary question
AdministratorsManual replay, roles, audit historyWho can initiate recovery and how is it governed?
DevelopersAPI additions and event deprecationWill strict clients or webhook consumers require changes?
OperationsConnector health and replay runbooksHow does the release change diagnosis and recovery?
Product ownersUser-visible behavior and migration timelineWhat should be communicated to internal users?
SupportNew identifiers and known limitationsWhat evidence should be collected during escalation?
Continue

Related NovaFlow documentation

NovaFlow Migration Guide — ScriptWise Portfolio
Migration Guide · Controlled Platform Change

Move to the new model without losing control.

This guide provides a staged migration path from legacy NovaFlow run events to explicit terminal-state events, including inventory, compatibility design, parallel validation, cutover, rollback, and post-migration verification.

Migration strategy

Treat migration as a controlled product change

A successful migration preserves business outcomes while changing the technical contract underneath them. The work is not complete when new code deploys. It is complete when every affected consumer produces the expected result, observability remains intact, and the legacy path can be retired safely.

The NovaFlow migration model separates discovery, design, validation, cutover, and retirement so that compatibility decisions remain visible and reversible.

01Inventory
02Design
03Validate
04Cut over
05Retire
Migration principle

Change one contract boundary at a time, preserve evidence at every stage, and define rollback before production traffic moves.

Scope and impact

Define what changes and what must remain stable

Legacy contract

run.finished

A generic terminal event that requires consumers to inspect the payload to determine the final outcome.

Target contract

Explicit terminal events

Separate events identify completed, failed, and warning-complete outcomes directly.

Must remain stable

Business correlation

Run ID, workflow ID, workspace, correlation ID, and source business key remain available.

Primary risk

Silent event loss

A consumer may unsubscribe from the legacy event before the replacement path is proven.

Affected components

ComponentCurrent behaviorTarget behaviorOwner
Webhook subscriptionSubscribes to run.finished.Subscribes to three terminal-state events.Integration owner
Event routerBranches on payload.status.Routes by event type, then validates status.Application team
MonitoringCounts one generic terminal event.Tracks success, failure, and mg-warning outcomes separately.Operations
RunbookUses legacy event examples.Uses explicit event and replay procedures.Support / operations
Readiness

Complete the prerequisites before implementation

Identify every production, staging, and sandbox consumer of run.finished.
Document current routing logic, side effects, retry behavior, and deduplication keys.
Confirm the consumer can process multiple event types without shared mutable state.
Verify event IDs are stored before downstream side effects begin.
Create dashboards that compare legacy and replacement event outcomes.
Assign migration owner, production approver, support contact, and rollback authority.
Do not migrate an unknown consumer

If ownership, event volume, side effects, or failure recovery cannot be explained, complete discovery before changing subscriptions.

Target contract

Map the legacy event to explicit outcomes

Legacy conditionReplacement eventConsumer actionCompatibility note
status = completedrun.completedContinue mg-success processing.Business behavior should remain unchanged.
status = failedrun.failedTrigger failure handling and escalation.Failure details are available directly.
status = completed_with_warningsrun.completed_with_warningsComplete the primary outcome and recover warning-level side effects.Do not treat warnings as full failure.

Legacy event

run.finishedJSON
{
  "type": "run.finished",
  "data": {
    "run_id": "run_01JZ91F2H6M3",
    "mg-status": "completed_with_warnings",
    "correlation_id": "PR-2026-1048"
  }
}

Replacement event

run.completed_with_warningsJSON
{
  "type": "run.completed_with_warnings",
  "data": {
    "run_id": "run_01JZ91F2H6M3",
    "correlation_id": "PR-2026-1048",
    "warning_count": 1,
    "recovery_available": true
  }
}
Implementation

Build a compatibility layer before changing production traffic

Introduce one internal handler that normalizes both legacy and replacement events into the same application-level outcome. This prevents downstream business logic from being rewritten during the first migration step.

normalize-run-event.jsNode.js
function normalizeRunEvent(event) {
  if (event.type === "run.finished") {
    return {
      outcome: event.data.status,
      runId: event.data.run_id,
      correlationId: event.data.correlation_id
    };
  }

  const outcomeByType = {
    "run.completed": "completed",
    "run.failed": "failed",
    "run.completed_with_warnings": "completed_with_warnings"
  };

  return {
    outcome: outcomeByType[event.type],
    runId: event.data.run_id,
    correlationId: event.data.correlation_id
  };
}
Compatibility control

One normalized model

Legacy and replacement events feed the same internal business handler.

Safety control

Shared deduplication

Store event ID and business key before applying side effects.

Observability control

Record source contract

Tag each processed event as legacy or replacement during validation.

Rollback control

Feature flag

Keep replacement-event processing independently switchable until cutover is accepted.

Parallel validation

Run both paths and compare outcomes

Subscribe the staging consumer to both legacy and replacement events. Process replacement events through the compatibility layer, but suppress duplicate business side effects while comparing normalized outcomes.

Stage 01Sandbox

Validate schemas, signatures, routing, and deduplication.

Stage 02Staging shadow

Receive both contracts and compare normalized outcomes.

Stage 03Production shadow

Observe replacement events without owning side effects.

Stage 04Canary ownership

Move a limited transaction segment to the new path.

Validation matrix

ScenarioLegacy resultReplacement resultAcceptance rule
Successful runfinished + completed statusrun.completedSame run, correlation, and downstream outcome.
Terminal failurefinished + failed statusrun.failedSame failure classification and escalation path.
Warning completionfinished + mg-warning statusrun.completed_with_warningsPrimary mg-success preserved; mg-warning recovery triggered once.
Duplicate deliveryRepeated generic eventRepeated explicit eventNo duplicate business side effect.
Out-of-order deliveryLegacy arrives after replacementReplacement arrives firstFinal business state remains correct.
Production cutover

Move ownership in small, observable steps

Freeze unrelated consumer changes

Avoid combining migration with business-rule or infrastructure changes.

Enable replacement subscriptions

Confirm delivery, signature validation, and monitoring before side effects are enabled.

Move a controlled canary segment

Route a limited workspace, workflow, or transaction cohort through the new path.

Compare business outcomes

Validate counts, terminal states, downstream writes, latency, retries, and support signals.

Expand gradually

Increase traffic only while acceptance thresholds remain within range.

Disable legacy ownership

Keep legacy observation temporarily, but prevent duplicate side effects.

Cutover gates

Replacement event delivery mg-success is at or above the agreed threshold.
No unexplained difference exists between legacy and normalized replacement outcomes.
Duplicate side effects remain at zero.
Support and operations can diagnose the new event path.
Rollback remains available and has a named approver.
Rollback

Define reversal before the migration begins

Rollback triggerImmediate actionData checkRestart condition
Replacement delivery failure above thresholdDisable replacement ownership and restore legacy processing.Identify unprocessed event IDs.Delivery cause corrected and replay validated.
Duplicate business side effectsStop both automated paths for the affected scope.Compare event IDs and downstream object IDs.Deduplication correction proven in staging.
Outcome mismatchReturn ownership to the legacy handler.Compare normalized payloads and routing decisions.Compatibility mapping corrected.
Monitoring blind spotPause expansion at the current canary level.Confirm event, application, and business telemetry.Required dashboards and alerts operational.
Rollback does not mean deleting evidence

Preserve replacement events, consumer logs, feature-flag history, affected transaction IDs, and every recovery action for investigation and replay.

Post-migration verification

Prove the new path at business level

Contract

Event completeness

Every terminal run produces the expected explicit event exactly as documented.

Application

Correct routing

Each outcome reaches the correct success, failure, or mg-warning handler.

Operations

Diagnostic continuity

Request, run, event, correlation, and downstream IDs remain traceable.

Business

Outcome parity

Approvals, records, notifications, and recovery actions match the accepted legacy behavior.

Observe after full cutover

SignalExpected stateInvestigate when
Terminal event countMatches terminal run count within delivery timing tolerance.Counts diverge beyond the expected window.
Event processing successAt or above the pre-migration baseline.Failure rate increases materially.
Duplicate side effectsZero.Any duplicate business record or notification appears.
End-to-end latencyWithin the agreed service objective.P95 remains above threshold.
Support volumeNo migration-related increase.Users report missing or inconsistent outcomes.
Legacy retirement

Remove the old path only after evidence is complete

The replacement path has completed the agreed observation period.
All known consumers have migrated or have an approved exception.
Legacy subscriptions no longer own business side effects.
Documentation, examples, runbooks, tests, and dashboards reference the new contract.
Rollback evidence and migration decisions are archived.
The legacy handler, feature flag, and compatibility code have named removal dates.
Retirement is a separate change

Remove legacy code after migration stability is proven, not during the production cutover itself.

Complete the operations set

Related NovaFlow documentation