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.
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 CommunicationTrust as a Strategy
How healthcare organizations can attract patients, strengthen their brand, improve communication, and build sustainable profitability through trust.
View the book on AmazonMost 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.
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.
No client assets, confidential processes, or proprietary documentation are reproduced.
Information architecture, terminology, navigation, and content patterns work as one system.
Each prototype is structured like documentation that could move into a real product workflow.
NovaFlow
Enterprise workflow platform for connected teams.
Product concept
NovaFlow helps operations teams design workflows, connect tools, manage access, automate repetitive processes, and surface knowledge through AI-assisted search.
Primary audiences
Core terminology
Explore the documentation system
Each prototype demonstrates a different documentation challenge, audience, and content pattern within one coherent product ecosystem.
Getting Started
Set up a workspace and reach the first successful workflow with minimal friction.
Feature Documentation
Explain a complex workflow automation feature through concepts, use cases, and configuration steps.
API Quickstart
Authenticate, send the first request, read the response, and handle an initial error.
API Reference
Define endpoints, parameters, request schemas, response objects, and error behavior.
Integration Guide
Connect NovaFlow to an external service and validate the data flow end to end.
Onboarding Documentation
Move a new team from account creation to first value through staged guidance.
Troubleshooting Guide
Diagnose failures through symptoms, likely causes, checks, and resolution paths.
Release Notes
Translate product changes into user impact, required action, and upgrade context.
Migration Guide
Move safely between product or API versions with clear prerequisites and rollback logic.
Knowledge Base
Resolve a common user problem through a concise, searchable support article.
Administrator Manual
Configure roles, permissions, governance rules, and workspace-level controls.
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.
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.
Name the workspace
Choose a name that people can identify quickly, such as Customer Operations.
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.
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.
Connect the task tool
Add the project where support requests should become tasks. Confirm that NovaFlow can create tasks and assign them to members.
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.
Add the trigger
Select New email received. Set the inbox to support@company.com and limit the trigger to unread messages.
Add the actions
- Classify request by billing, technical, or account topic.
- Create task with the email subject as the task title.
- Assign owner based on the classification result.
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.
Send a test message
Send an email with the subject Cannot update payment method. The classifier should identify it as a billing request.
Review the run
Confirm that every step shows Successful, the task contains the correct subject, and the billing owner is assigned.
5. Publish and monitor
Select Publish workflow, review the permissions summary, and confirm. NovaFlow begins listening for new inbox events immediately.
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.
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.
Condition
A rule that compares runtime data with a value, set, pattern, or expression.
Branch
A named execution path that runs only when its condition evaluates to true.
Fallback
An optional default path that runs when no explicit condition matches.
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 |
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.
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.
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.
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.
{
"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"
}
}
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
When two branches can match the same input, only the first branch runs. Reorder branches or make the conditions mutually exclusive.
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.
Best practices
- Name branches by outcome. Use Finance review, not Branch 2.
- Keep conditions mutually exclusive. Avoid relying on order to resolve ambiguity.
- Use a fallback. Unknown values should create a visible exception path.
- Separate business rules from credentials. Branch logic should not contain secrets.
- Document ownership. Identify who approves rule changes and who handles failures.
- Test before publishing. Validate every branch and every boundary value.
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.
Identity
Control authentication, provisioning, sessions, domains, and privileged access.
Governance
Define ownership, approvals, naming, lifecycle, and publishing requirements.
Auditability
Monitor security events, configuration changes, and workflow activity.
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.
| Setting | Recommended value | Why it matters |
|---|---|---|
| Workspace name | Durable business or platform name | Avoid temporary project names that lose meaning |
| Primary domain | Verified corporate domain | Supports trusted provisioning and domain controls |
| Default time zone | Operational reporting time zone | Keeps schedules, logs, and reviews consistent |
| Default language | Primary operating language | Standardizes notifications and system guidance |
| Data region | Approved residency region | Aligns 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.
| Role | Build workflows | Publish | Manage integrations | Manage access | View audit logs |
|---|---|---|---|---|---|
| Workspace Admin | Yes | Yes | Yes | Yes | Yes |
| Workflow Manager | Yes | Yes | Approved only | No | Limited |
| Builder | Yes | By approval | No | No | No |
| Member | No | No | No | No | No |
| Auditor | No | No | No | No | Read only |
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.
SAML SSO
Authenticate through the organization’s identity provider.
SCIM
Provision, update, and deactivate users automatically.
MFA
Require an additional verification factor for privileged users.
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.comGovern integrations and credentials
Every production connection should have an approved owner, documented scopes, a rotation plan, and a defined fallback when access fails.
Apply workflow governance
Standardize how workflows are named, reviewed, published, changed, monitored, deprecated, and archived.
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: falseMonitor 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.
{
"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 category | Examples | Recommended alert |
|---|---|---|
| Identity | SSO disabled, admin MFA changed | Immediate |
| Access | Admin assigned, role elevated | Immediate |
| Integration | Connection created, scope changed | High priority |
| Workflow | Published, disabled, ownership changed | Daily review |
| Data | Export requested, retention changed | Immediate |
Manage data and retention
Classify the data processed by each workflow and apply retention, export, deletion, and access rules that match organizational policy.
Classify
Identify personal, financial, confidential, and regulated data.
Retain
Set limits for run history, logs, attachments, and exports.
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.
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.
Administrator review cadence
| Cadence | Review | Owner |
|---|---|---|
| Weekly | Failed runs, expiring credentials, unresolved incidents | Platform operations |
| Monthly | Unused connections, orphaned workflows, publish activity | Workspace admin |
| Quarterly | Privileged roles, access recertification, policy exceptions | Security and compliance |
| Annually | Retention, recovery procedures, workspace architecture | Platform owner |
A secure workspace is maintained through recurring review, not a one-time configuration project.
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.
Identity
Control authentication, provisioning, sessions, domains, and privileged access.
Governance
Define ownership, approvals, naming, lifecycle, and publishing requirements.
Auditability
Monitor security events, configuration changes, and workflow activity.
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.
| Setting | Recommended value | Why it matters |
|---|---|---|
| Workspace name | Durable business or platform name | Avoid temporary project names that lose meaning |
| Primary domain | Verified corporate domain | Supports trusted provisioning and domain controls |
| Default time zone | Operational reporting time zone | Keeps schedules, logs, and reviews consistent |
| Default language | Primary operating language | Standardizes notifications and system guidance |
| Data region | Approved residency region | Aligns 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.
| Role | Build workflows | Publish | Manage integrations | Manage access | View audit logs |
|---|---|---|---|---|---|
| Workspace Admin | Yes | Yes | Yes | Yes | Yes |
| Workflow Manager | Yes | Yes | Approved only | No | Limited |
| Builder | Yes | By approval | No | No | No |
| Member | No | No | No | No | No |
| Auditor | No | No | No | No | Read only |
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.
SAML SSO
Authenticate through the organization’s identity provider.
SCIM
Provision, update, and deactivate users automatically.
MFA
Require an additional verification factor for privileged users.
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.comGovern integrations and credentials
Every production connection should have an approved owner, documented scopes, a rotation plan, and a defined fallback when access fails.
Apply workflow governance
Standardize how workflows are named, reviewed, published, changed, monitored, deprecated, and archived.
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: falseMonitor 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.
{
"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 category | Examples | Recommended alert |
|---|---|---|
| Identity | SSO disabled, admin MFA changed | Immediate |
| Access | Admin assigned, role elevated | Immediate |
| Integration | Connection created, scope changed | High priority |
| Workflow | Published, disabled, ownership changed | Daily review |
| Data | Export requested, retention changed | Immediate |
Manage data and retention
Classify the data processed by each workflow and apply retention, export, deletion, and access rules that match organizational policy.
Classify
Identify personal, financial, confidential, and regulated data.
Retain
Set limits for run history, logs, attachments, and exports.
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.
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.
Administrator review cadence
| Cadence | Review | Owner |
|---|---|---|
| Weekly | Failed runs, expiring credentials, unresolved incidents | Platform operations |
| Monthly | Unused connections, orphaned workflows, publish activity | Workspace admin |
| Quarterly | Privileged roles, access recertification, policy exceptions | Security and compliance |
| Annually | Retention, recovery procedures, workspace architecture | Platform owner |
A secure workspace is maintained through recurring review, not a one-time configuration project.
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.
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.
All production requests use HTTPS.
Major ar-version is encoded in the path.
JSON request and response bodies.
Example: 2026-07-23T09:42:18Z.
Authentication headers
Authorization: Bearer nf_live_••••••••
NovaFlow-Workspace: ws_01J9KX2A8Q
Content-Type: application/jsonTokens can be authorized for multiple workspaces. The NovaFlow-Workspace header makes tenant selection deterministic and auditable.
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.
Create a workflow
Creates a draft workflow in the selected workspace. Use an idempotency key when the client may retry the request.
| Field | Type | Requirement | Description |
|---|---|---|---|
| name | string | Required | Human-readable workflow name. Maximum 120 characters. |
| environment | enum | Required | sandbox or production. |
| trigger | object | Required | Initial workflow trigger configuration. |
| description | string | Optional | Internal summary. Maximum 500 characters. |
| tags | array<string> | Optional | Up to 20 searchable labels. |
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"}}'{
"id": "wf_01JA2Z8P4N",
"object": "workflow",
"name": "Purchase approval",
"status": "draft",
"environment": "sandbox",
"ar-version": 1
}List workflows
Returns a cursor-paginated collection with filtering by status, environment, and sort order.
Retrieve a workflow
Returns the latest representation of a workflow, including lifecycle state and ar-active version.
Update a workflow
Applies a partial update to a draft workflow. Published versions are immutable.
Publish a workflow
Validates the draft and creates an immutable published version.
Archive a workflow
Moves the workflow to an archived state while preserving audit visibility.
Workflow run endpoints
Runs represent individual workflow executions and expose execution state, timing, input, output, and failure metadata.
Start a workflow run
Starts an execution of a published workflow and returns a queued run resource.
Retrieve run status
Returns queued, running, succeeded, failed, or canceled.
List workflow runs
Filters by workflow, status, environment, correlation ID, and time range.
Cancel a workflow run
Requests cancellation of a queued or running execution.
Webhook endpoints
Webhooks deliver signed event notifications to external systems. Every delivery includes a stable event ID, timestamp, and HMAC SHA-256 signature.
Create a webhook endpoint
Registers an HTTPS ar-endpoint and one or more event subscriptions.
Store it immediately in a secrets manager. NovaFlow cannot reveal the original value after creation.
List webhook endpoints
Returns ar-endpoint status, subscriptions, and delivery metadata.
Rotate a signing secret
Generates a replacement secret with a short overlap window.
Delete a webhook endpoint
Stops future deliveries and removes the configuration.
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.
{
"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"
}
}| Status | Category | Retry? | Client behavior |
|---|---|---|---|
| 400 | Malformed request | No | Correct request syntax or payload. |
| 401 | Authentication | No | Replace or correct credentials. |
| 403 | Authorization | No | Review scopes or workspace access. |
| 409 | Conflict | Conditional | Read current state before deciding. |
| 429 | Rate limit | Yes | Honor Retry-After and back off. |
| 5xx | Service failure | Yes | Retry with bounded exponential backoff and jitter. |
Every ar-endpoint follows the same order: purpose, authorization, inputs, schema, examples, success response, and error behavior.
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.
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.
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.
CRM
Owns the original customer and purchase-request data.
NovaFlow
Validates, routes, approves, and records each workflow execution.
ERP
Receives approved financial records and creates the purchase order.
Slack + Analytics
Receive notifications and execution telemetry without becoming systems of record.
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.
Recommended enterprise topology
Place an integration service between internal systems and NovaFlow. The service owns authentication, transformation, correlation IDs, retry policy, and deployment lifecycle.
Choose the interaction model
| Pattern | Use when | Trade-off |
|---|---|---|
| Synchronous API | The caller needs immediate validation or a resource ID. | Tightly coupled to request latency and availability. |
| Asynchronous run | The workflow may take seconds or minutes. | Requires status polling or ig-event handling. |
| Webhook | The client should react to state changes without polling. | Requires signature validation and delivery recovery. |
| Queue | Traffic spikes, ordering, or backpressure must be absorbed. | Adds operational complexity and eventual consistency. |
Authentication and authorization flow
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 field | NovaFlow field | Transform | Validation | Owner |
|---|---|---|---|---|
| purchaseRequestId | input.request_id | String, unchanged | Required; unique per CRM | CRM |
| customerId | input.customer.id | String, unchanged | Required | CRM |
| customerName | input.customer.name | Trim whitespace | 1–160 characters | CRM |
| amount | input.purchase.amount_minor | Decimal × 100 | Positive integer | CRM |
| currency | input.purchase.currency | Uppercase ISO code | Three characters | CRM |
| createdAt | input.source.created_at | Convert to UTC | ISO 8601 | CRM |
Canonical payload
{
"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"}
}Do not guess currency, timezone, ownership, or identifier semantics. Treat unresolved mappings as design issues, not implementation details.
Trace one transaction end to end
Start the workflow run
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"}}'Use the same business correlation ID across CRM logs, NovaFlow runs, ERP records, webhook events, and support tickets.
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.
Idempotency key
Reuse the source business ID so retried create or execute operations return the original result.
Bounded retries
Retry 429 and selected 5xx responses with exponential backoff and jitter.
Event deduplication
Persist the webhook ig-event ID before applying downstream side effects.
Dead-letter handling
Move exhausted messages to a review queue with payload, attempts, and last error.
Retry decision matrix
| Failure | Retry? | Action |
|---|---|---|
| 400 validation error | No | Correct the source data or mapping. |
| 401 invalid credential | No | Rotate or replace the credential. |
| 409 state conflict | Conditional | Read current state before deciding. |
| 429 rate limit | Yes | Honor Retry-After and add jitter. |
| 502 / 503 / 504 | Yes | Retry a bounded number of times. |
| Webhook timeout | Handled by NovaFlow | Return 2xx only after durable acceptance. |
Webhook signature verification
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");
}Protect credentials, data, and administrative actions
Do not issue one all-powerful token for every environment and service. Scope credentials to one workload, one environment, and the minimum required operations.
Prove the contract before production
| Test layer | Purpose | Example |
|---|---|---|
| Schema validation | Catch malformed source data before API calls. | Reject missing currency or invalid timestamps. |
| Contract test | Verify request and response compatibility. | Assert required fields and stable error codes. |
| Sandbox integration | Validate real authentication and resource behavior. | Create and execute a non-production workflow. |
| Failure injection | Prove retry, deduplication, and recovery logic. | Simulate 429, timeout, duplicate webhook, ERP outage. |
| Load test | Measure throughput and backpressure behavior. | Replay peak-hour traffic with realistic payload sizes. |
Deployment sequence
Local mocks and schema validation.
Real NovaFlow API and test credentials.
Production-like data volume and dependencies.
Limited production traffic with rollback controls.
Release readiness checklist
Monitor the integration as a business process
| Signal | Why it matters | Suggested alert |
|---|---|---|
| Request ig-success rate | Detects broad API or client failures. | Below 99.5% for 10 minutes. |
| End-to-end latency | Measures business completion, not only API response time. | P95 above agreed service objective. |
| Retry volume | Reveals degraded dependencies before hard failure. | Threefold increase over baseline. |
| Webhook delivery failures | Detects broken ig-event consumption. | Any sustained failure after automatic retries. |
| Dead-letter queue depth | Shows unresolved business transactions. | Above zero beyond the response window. |
| Mapping rejection rate | Identifies source-data quality regression. | Above 1% of incoming records. |
Troubleshooting matrix
| Symptom | Likely cause | Diagnosis | Resolution |
|---|---|---|---|
| 401 responses | Expired or wrong-environment token | Check token prefix and audit logs. | Rotate the correct credential. |
| Duplicate ERP records | Missing idempotency or ig-event deduplication | Compare correlation and ig-event IDs. | Persist processed IDs and replay safely. |
| Runs remain queued | Capacity or workflow dependency issue | Inspect run status and platform notices. | Pause intake or apply backpressure. |
| Webhook signature fails | Raw body changed or secret mismatch | Compare timestamp, raw bytes, and ig-active secret. | Use the unmodified body and current secret. |
Move from implementation to operations
Continue with Troubleshooting for symptom-based recovery procedures, or return to API Reference for exact endpoint contracts.
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.
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.
The business correlation ID should connect source-system logs, the NovaFlow run, webhook events, downstream records, monitoring traces, and the support case.
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.
{
"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"
}
Classify the failure before choosing an action
The API rejects the request before a workflow run starts.
- 401 or 403 response
- Invalid token or missing scope
- Wrong workspace or environment
The request reaches NovaFlow but violates the data contract.
- 400 or 422 response
- Missing required field
- Type, timezone, or currency mismatch
The run starts but remains blocked, delayed, or failed.
- Long-running step
- Missing approval
- Expression or configuration error
NovaFlow completes an internal step but cannot deliver the side effect.
- ERP or CRM unavailable
- Expired connector credential
- Rate limit or schema drift
The event exists, but the consumer does not accept or process it.
- Non-2xx endpoint response
- Signature mismatch
- Duplicate or delayed event
Multiple unrelated transactions fail in the same period.
- Broad increase in 5xx errors
- Cross-workflow latency spike
- Regional ts-status degradation
Interpret the response before retrying
| Response | Meaning | Check | Recommended action |
|---|---|---|---|
| 400 Bad Request | The payload or request syntax is invalid. | JSON structure, headers, field names, encoding. | Correct the request. Do not retry unchanged. |
| 401 Unauthorized | The credential is missing, invalid, or expired. | Bearer token, environment, secret rotation. | Replace the credential, then send a new request. |
| 403 Forbidden | The credential is valid but lacks required access. | Workspace, role, API scope, resource ownership. | Grant the minimum required scope. |
| 409 Conflict | The requested change conflicts with current state. | Resource version, run status, duplicate operation. | Read the current state before deciding whether to retry. |
| 422 Validation Error | The payload is syntactically valid but violates the contract. | Required fields, enums, formats, business rules. | Correct the source data or mapping. |
| 429 Rate Limited | The client exceeded an allowed request rate. | Retry-After, concurrency, burst volume. | Back off with jitter and reduce concurrency. |
| 502 / 503 / 504 | A 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
{
"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"
}
}
Authentication, authorization, validation, and mapping failures require correction. Automated retries are appropriate only for explicitly transient conditions.
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 status | Interpretation | First check | Recovery path |
|---|---|---|---|
| queued | The run is accepted but has not started. | Queue age and workspace concurrency. | Wait within the expected window; investigate sustained backlog. |
| running | At least one step is actively executing. | Current step and elapsed time. | Compare with the step timeout and dependency latency. |
| waiting_for_approval | The run requires a human decision. | Assigned approver and due date. | Reassign or remind according to policy. |
| waiting_for_connector | A downstream dependency has not completed. | Connector health, credential, and retry count. | Restore the dependency, then retry or replay safely. |
| failed | A terminal error stopped execution. | Failed step, error code, preserved outputs. | Correct the cause and resume or create a controlled replay. |
| completed_with_warnings | The 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
curl --request GET \
"https://api.novaflow.dev/v1/runs/run_01JZ91F2H6M3" \
--header "Authorization: Bearer $NOVAFLOW_API_KEY" \
--header "NovaFlow-Workspace: $WORKSPACE_ID"
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.
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.
No event received
Confirm the endpoint URL, subscribed event type, environment, and delivery log.
Repeated deliveries
Persist the event ID and make downstream side effects idempotent.
Signature mismatch
Verify against the unmodified raw body, correct timestamp, and ts-active secret.
Delivery succeeds, action missing
Trace the event through the consumer queue and downstream transaction logs.
Search by event ID, run ID, or correlation ID in the NovaFlow delivery history.
Review response code, duration, destination, retry count, and the final delivery state.
Use the raw request body and compare the configured secret with the endpoint environment.
Return 2xx only after the event has been stored or placed on a durable internal queue.
After correction, replay the event and verify that deduplication prevents duplicate effects.
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.
| Signal | Likely cause | Evidence | Owner |
|---|---|---|---|
| Credential rejected | Expired secret, revoked token, wrong tenant. | Connector authentication log and rotation history. | Integration owner |
| Connection timeout | Network path or downstream outage. | Destination health, DNS, firewall, regional telemetry. | Platform / network |
| Permission denied | Destination role no longer allows the operation. | Destination audit log and assigned role. | Destination administrator |
| Payload rejected | Schema drift or unsupported field value. | Destination error payload and contract version. | Application owner |
| Rate limited | Concurrency or request burst exceeds destination limit. | 429 response, quota dashboard, retry pattern. | Integration owner |
| Partial write | Destination accepted some operations before failure. | Destination transaction and object IDs. | Joint investigation |
Credential changes can restore one workflow while breaking another. Confirm scope, environment, overlap window, dependent services, and rollback before rotation.
Choose retry, replay, resume, or compensation
| Recovery action | Use when | Primary risk | Required control |
|---|---|---|---|
| Retry request | The original request failed before any durable result. | Duplicate creation after a client timeout. | Reuse the original idempotency key. |
| Resume run | The run preserved completed steps and supports continuation. | Resuming from an invalid state. | Confirm the corrected dependency and current run state. |
| Replay event | The event exists but downstream delivery or processing failed. | Duplicate side effects. | Deduplicate by event ID and business key. |
| Reprocess dead letter | A queued transaction exhausted automatic attempts. | Reintroducing unresolved ts-bad data. | Approve the cause correction before reprocessing. |
| Compensating action | A completed side effect must be logically reversed. | Incomplete business rollback. | Use an auditable domain-specific compensation procedure. |
A successful API response is not enough. Verify the expected business state in NovaFlow and every authoritative downstream system.
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.
Critical production impact
Security exposure, confirmed data loss, or a broad outage blocking a critical business process.
Major degraded operation
Repeated failures affecting multiple users or workflows with no practical workaround.
Limited functional issue
A contained failure with an available workaround and no integrity risk.
Question or documentation gap
Clarification, expected-behavior question, or improvement request without current service impact.
Include these fields in the support case
Operational ts-decision checklist
Record identifiers and error data before changing configuration or replaying work.
Determine whether one transaction, one workflow, one workspace, or the wider platform is affected.
Locate the exact point where expected state and observed state diverge.
Correct permanent contract errors; apply bounded retries only to transient failures.
Use idempotency, deduplication, step-level recovery, or compensation as appropriate.
Confirm final state across NovaFlow and every system of record.
Related NovaFlow documentation
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 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.
If a customer cannot tell whether a change affects them, the release note is incomplete.
NovaFlow 4.8 · July 2026
Production rollout complete
Released to all production workspaces between July 21 and July 23, 2026.
No breaking API changes
Existing v1 integrations continue to operate without request or response changes.
Review webhook consumers
Consumers using legacy run.finished events should begin migration planning.
Safer recovery controls
Administrators can replay failed events from the delivery history with full audit traceability.
Review required actions first, then scan API, workflow, connector, and administrator changes relevant to your environment.
Complete these rn-checks before the rn-next release window
run.finished event.run.completed and run.failed events.| Action | Owner | Deadline | Risk if skipped |
|---|---|---|---|
| Assess legacy webhook usage | Integration owner | Before September 15, 2026 | Missed events after deprecation removal. |
| Update internal runbook | Operations lead | Before rn-next incident review | Slower and less controlled recovery. |
| Validate replay deduplication | Application owner | Before enabling manual replay in production | Duplicate downstream side effects. |
New workflow and administrator capabilities
Manual event replay
Administrators can replay failed webhook deliveries directly from delivery history after correcting the destination issue.
Run detail timeline
The run page now separates workflow execution, connector delivery, retry attempts, and final recovery action.
Schema validation feedback
Validation errors now include the exact field path, rejected value type, and expected contract rule.
Connector health state
Connector rn-cards display current authentication state, last successful call, and recent error rate.
Manual event replay safeguards
Compatibility-preserving API improvements
| Area | Change | Compatibility | Action |
|---|---|---|---|
| Run retrieval | GET /v1/runs/{run_id} now returns recovery_state. | Additive | No action unless strict response validation is enabled. |
| Validation errors | Error objects now include field and expected. | Additive | Update error rendering when useful. |
| Webhook delivery | Delivery attempts include replay_origin. | Additive | Use for audit and support context. |
| Event model | run.finished is deprecated in favor of terminal-state events. | Deprecation | Plan migration before removal. |
Updated run response
{
"id": "run_01JZ91F2H6M3",
"rn-status": "completed_with_warnings",
"recovery_state": {
"replay_available": true,
"failed_event_count": 1,
"last_recovery_action": null
}
}
Clients that reject unknown response properties should update their parsers before adopting this release.
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 item | Replacement | Deprecated | Removal target |
|---|---|---|---|
run.finished | run.completed, run.failed, run.completed_with_warnings | July 23, 2026 | January 31, 2027 |
Run both old and new event subscriptions in parallel, compare outcomes, and switch production consumers only after successful validation.
Fixes included in NovaFlow 4.8
| Reference | Issue | Resolution | Affected area |
|---|---|---|---|
| NF-4821 | Webhook retry history could display attempts out of sequence after manual refresh. | Attempts are now ordered by durable creation timestamp. | Operations UI |
| NF-4873 | Connector health could remain degraded after successful credential rotation. | Health state now recalculates after the first successful authenticated request. | Connectors |
| NF-4902 | Validation errors for nested arrays omitted the array index. | Field paths now include full indexed notation. | API validation |
| NF-4938 | Run 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 issues and current workarounds
Large replay payload preview
Payloads above 500 KB may take several seconds to render in the browser. Download the sanitized payload instead.
Connector health delay
Health rn-status may take up to two minutes to reflect a newly restored downstream dependency.
Each workaround remains linked to a tracked engineering issue and should be removed when the product behavior is corrected.
How the release was deployed
Production-like validation with NovaFlow operational teams.
Selected workspaces validated replay and connector telemetry.
Five percent of production workspaces received the release.
Rollout completed after error and latency rn-checks remained within target.
Post-release validation
What each audience should review
| Audience | Review first | Primary question |
|---|---|---|
| Administrators | Manual replay, roles, audit history | Who can initiate recovery and how is it governed? |
| Developers | API additions and event deprecation | Will strict clients or webhook consumers require changes? |
| Operations | Connector health and replay runbooks | How does the release change diagnosis and recovery? |
| Product owners | User-visible behavior and migration timeline | What should be communicated to internal users? |
| Support | New identifiers and known limitations | What evidence should be collected during escalation? |
Related NovaFlow documentation
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.
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.
Change one contract boundary at a time, preserve evidence at every stage, and define rollback before production traffic moves.
Define what changes and what must remain stable
run.finished
A generic terminal event that requires consumers to inspect the payload to determine the final outcome.
Explicit terminal events
Separate events identify completed, failed, and warning-complete outcomes directly.
Business correlation
Run ID, workflow ID, workspace, correlation ID, and source business key remain available.
Silent event loss
A consumer may unsubscribe from the legacy event before the replacement path is proven.
Affected components
| Component | Current behavior | Target behavior | Owner |
|---|---|---|---|
| Webhook subscription | Subscribes to run.finished. | Subscribes to three terminal-state events. | Integration owner |
| Event router | Branches on payload.status. | Routes by event type, then validates status. | Application team |
| Monitoring | Counts one generic terminal event. | Tracks success, failure, and mg-warning outcomes separately. | Operations |
| Runbook | Uses legacy event examples. | Uses explicit event and replay procedures. | Support / operations |
Complete the prerequisites before implementation
run.finished.If ownership, event volume, side effects, or failure recovery cannot be explained, complete discovery before changing subscriptions.
Map the legacy event to explicit outcomes
| Legacy condition | Replacement event | Consumer action | Compatibility note |
|---|---|---|---|
status = completed | run.completed | Continue mg-success processing. | Business behavior should remain unchanged. |
status = failed | run.failed | Trigger failure handling and escalation. | Failure details are available directly. |
status = completed_with_warnings | run.completed_with_warnings | Complete the primary outcome and recover warning-level side effects. | Do not treat warnings as full failure. |
Legacy event
{
"type": "run.finished",
"data": {
"run_id": "run_01JZ91F2H6M3",
"mg-status": "completed_with_warnings",
"correlation_id": "PR-2026-1048"
}
}
Replacement event
{
"type": "run.completed_with_warnings",
"data": {
"run_id": "run_01JZ91F2H6M3",
"correlation_id": "PR-2026-1048",
"warning_count": 1,
"recovery_available": true
}
}
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.
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
};
}
One normalized model
Legacy and replacement events feed the same internal business handler.
Shared deduplication
Store event ID and business key before applying side effects.
Record source contract
Tag each processed event as legacy or replacement during validation.
Feature flag
Keep replacement-event processing independently switchable until cutover is accepted.
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.
Validate schemas, signatures, routing, and deduplication.
Receive both contracts and compare normalized outcomes.
Observe replacement events without owning side effects.
Move a limited transaction segment to the new path.
Validation matrix
| Scenario | Legacy result | Replacement result | Acceptance rule |
|---|---|---|---|
| Successful run | finished + completed status | run.completed | Same run, correlation, and downstream outcome. |
| Terminal failure | finished + failed status | run.failed | Same failure classification and escalation path. |
| Warning completion | finished + mg-warning status | run.completed_with_warnings | Primary mg-success preserved; mg-warning recovery triggered once. |
| Duplicate delivery | Repeated generic event | Repeated explicit event | No duplicate business side effect. |
| Out-of-order delivery | Legacy arrives after replacement | Replacement arrives first | Final business state remains correct. |
Move ownership in small, observable steps
Avoid combining migration with business-rule or infrastructure changes.
Confirm delivery, signature validation, and monitoring before side effects are enabled.
Route a limited workspace, workflow, or transaction cohort through the new path.
Validate counts, terminal states, downstream writes, latency, retries, and support signals.
Increase traffic only while acceptance thresholds remain within range.
Keep legacy observation temporarily, but prevent duplicate side effects.
Cutover gates
Define reversal before the migration begins
| Rollback trigger | Immediate action | Data check | Restart condition |
|---|---|---|---|
| Replacement delivery failure above threshold | Disable replacement ownership and restore legacy processing. | Identify unprocessed event IDs. | Delivery cause corrected and replay validated. |
| Duplicate business side effects | Stop both automated paths for the affected scope. | Compare event IDs and downstream object IDs. | Deduplication correction proven in staging. |
| Outcome mismatch | Return ownership to the legacy handler. | Compare normalized payloads and routing decisions. | Compatibility mapping corrected. |
| Monitoring blind spot | Pause expansion at the current canary level. | Confirm event, application, and business telemetry. | Required dashboards and alerts operational. |
Preserve replacement events, consumer logs, feature-flag history, affected transaction IDs, and every recovery action for investigation and replay.
Prove the new path at business level
Event completeness
Every terminal run produces the expected explicit event exactly as documented.
Correct routing
Each outcome reaches the correct success, failure, or mg-warning handler.
Diagnostic continuity
Request, run, event, correlation, and downstream IDs remain traceable.
Outcome parity
Approvals, records, notifications, and recovery actions match the accepted legacy behavior.
Observe after full cutover
| Signal | Expected state | Investigate when |
|---|---|---|
| Terminal event count | Matches terminal run count within delivery timing tolerance. | Counts diverge beyond the expected window. |
| Event processing success | At or above the pre-migration baseline. | Failure rate increases materially. |
| Duplicate side effects | Zero. | Any duplicate business record or notification appears. |
| End-to-end latency | Within the agreed service objective. | P95 remains above threshold. |
| Support volume | No migration-related increase. | Users report missing or inconsistent outcomes. |
Remove the old path only after evidence is complete
Remove legacy code after migration stability is proven, not during the production cutover itself.
Related NovaFlow documentation
Lost in the documentation?
Return to the NovaFlow Documentation Hub and continue exploring the complete documentation ecosystem.
↑ Back to Documentation Hub