features
Built For Processes that need to run correctly every time
Nawfe gives your team a no-code way to build workflows, assign ownership, collect information, route approvals, schedule recurring work, and track every execution from start to finish.
How Nawfe works
Build the process once. Run it every time you need work to happen.
Nawfe is built around a simple idea: your business already has repeatable processes. Nawfe gives those processes a place to run.
Create a Process for work your team does again and again - like onboarding a new hire, reviewing a contract, preparing for an audit, collecting a field report, or approving a client handoff.
Each Process is built from Nodes, which are the steps in the workflow. Nodes can collect forms, assign work, route approvals, trigger reminders, branch based on logic, or document what happened.
Every time the Process runs, Nawfe creates an Execution. That Execution tracks the live instance of the workflow from start to finish, showing who owns each step, what is waiting, what is complete, and what needs attention.
When the work is done, the Execution Timeline gives you a clear record of what happened, when it happened, who completed it, and what information was submitted.
What differentiates Nawfe
Built for execution, not just organization.
Task boards help teams organize work. Spreadsheets help teams track information. Documents help teams describe how a process should work.
But critical business processes need more than organization and documentation. They need structure, ownership, timing, routing, required inputs, approvals, reminders, and a clear record of what happened.
Nawfe is the execution layer. It's built for the moment work needs to move from one step to the next without getting lost in email, Slack, meetings, or someone’s memory.
It gives your team a place to actually run the process — not just talk about it, document it, or track it after the fact.
Workflow builder
Build workflows visually - No code required
Use Nawfe’s drag-and-drop builder to map each step of a repeatable process: forms, approvals, assignments, reminders, logic, delays, and reviews.
Define what happens next, who owns it, and what information is required so your team can run the process consistently every time.
With the Workflow Builder, you can:
Add forms, tasks, approvals, reviews, reminders, and logic
Connect steps in the order work should move
Assign owners to users or teams
Require information before the next step begins
Branch workflows based on responses or decisions
Publish repeatable processes your team can run again and again
Whether you’re building a simple approval process or a multi-team onboarding workflow, Nawfe helps you create a process your team can actually follow.
Starting an execution
Start workflows the way your business actually works.
Every live run of a Nawfe process is called an Execution.
Executions can be started manually by your team, launched automatically on a schedule, or triggered when someone submits an embedded form. That means a workflow can begin from an internal request, a recurring operational routine, a client intake form, a field submission, or any other real-world starting point.
Once started, Nawfe turns that request or recurring process into a trackable workflow with clear owners, due dates, required steps, and a complete execution history.
Manual Start
Launch a workflow whenever a process needs to begin, like a contract review, client onboarding, employee offboarding, or internal approval request.
Scheduled Start
Automatically create executions for recurring work, like daily reports, weekly check-ins, monthly inspections, quarterly reviews, or annual compliance tasks.
Embedded Form Start
Let a form submission create the execution automatically, like a client intake request, vendor onboarding form, support escalation, field report, or customer data request.
Forms & data collection
Collect the right information at the right step
A workflow is only as good as the information moving through it. Nawfe lets you collect structured information directly inside a workflow using forms, required fields, file uploads, notes, and confirmations.
That means requests, approvals, handoffs, reports, and reviews can include the context needed before the next step begins — reducing missing information, manual follow-ups, and incomplete submissions.
Key answers can be stored as execution variables, allowing information collected early in the process to be referenced, shared, and used later in the workflow. A client name, request type, deadline, approval answer, uploaded file, or field report detail can travel with the execution instead of getting buried in a form response, email thread, or spreadsheet.
Use collected information to give downstream assignees context, support approvals, personalize notifications, route decisions, and keep every step connected to the same source of truth.
With forms and execution variables, you can:
Capture structured data inside workflow steps
Store key responses as reusable execution variables
Carry submitted information into downstream steps
Show relevant context to reviewers, approvers, and assignees
Use form responses to drive branching logic
Include collected details in notifications or task instructions
Keep submissions, files, and decisions attached to the execution history
Workflow logic
Let the workflow adapt to the work.
Nawfe logic helps each execution follow the right path based on the information collected along the way.
Route work using conditions, responses, approvals, execution variables, and AND/OR rules. Show or hide form fields, make fields required only when they apply, and auto-populate information that has already been collected.
Simple requests can move quickly. Complex requests can trigger the extra steps, reviews, approvals, or escalations they need.
With workflow logic, you can:
Route executions based on form responses, approvals, variables, or conditions
Use AND/OR rules to support more complex decision paths
Send different request types to different teams
Trigger extra review steps when risk, value, or complexity increases
Skip unnecessary steps when they do not apply
Show, hide, require, or auto-populate form fields based on prior answers
Keep simple cases simple while still supporting exceptions
Assignments & ownership
Make ownership impossible to miss.
Nawfe assigns each step to the right individual or team so everyone knows what they own, what is waiting, and when action is needed.
Ownership can be fixed or dynamic. Steps can route to a specific user, a team, or an owner determined by workflow data like department, request type, location, project, customer, risk level, or approval requirement.
That keeps handoffs clear and prevents work from stalling because no one knew who was responsible.
With assignments and ownership, you can:
Assign workflow steps to specific users or teams
Dynamically assign owners based on form responses or execution variables
Route work by department, location, request type, project, customer, or risk
Give assignees clear instructions, due dates, and required actions
Make handoffs visible across the execution
Keep accountability tied to the execution history
Due dates & notifications
Keep work moving without manual follow-up
Nawfe ties due dates, reminders, and notifications directly to the workflow so assignees know when action is needed.
Notify the right person or team when a step becomes available, remind owners before work is overdue, and surface delayed steps before they turn into bigger process problems.
That keeps work moving with less chasing, fewer missed handoffs, and clearer accountability across every execution.
With due dates and notifications, you can:
Add due dates to workflow steps
Notify users, teams, or external participants when action is needed
Alert owners when a step becomes available
Remind assignees before work becomes overdue
Surface overdue steps to process owners
Reduce manual follow-ups across email, chat, and meetings
Help managers spot stalled work before it creates delays
External participants
Bring external stakeholders into your workflow without losing control.
Not every workflow happens entirely inside your company.
Nawfe lets you define external participants — like clients, vendors, contractors, candidates, customers, or partners — and include them when their input is needed. They can be notified, complete forms, upload files, submit information, or respond to workflow steps without accessing your full internal workspace.
That keeps outside handoffs connected to the execution, so external input is collected, tracked, and recorded in the same workflow your team is already using.
With external participants, you can:
Notify outside stakeholders when action is needed
Collect forms, files, confirmations, or required details
Keep external submissions tied to the execution
Route submitted information to the right internal owner
Control what external participants can see and complete
Reduce disconnected emails, shared folders, and manual follow-ups
Approvals & reviews
Route decisions without burying them in an email.
Approvals are one of the easiest places for processes to stall. Nawfe turns reviews and approvals into structured workflow steps instead of scattered email threads, Slack messages, or informal signoffs.
Approvers can review submitted information, uploaded files, notes, execution variables, and prior steps before making a decision. They can approve, reject, request changes, or route the execution forward based on the outcome.
Every decision stays tied to the execution history, giving your team a clear record of who approved what, when, and why.
With approvals and reviews, you can:
Add review and approval steps directly inside a workflow
Route approvals to individuals, teams, or dynamic owners
Give reviewers the context they need to make decisions
Approve, reject, request changes, or return work for correction
Move the workflow forward based on approval outcomes
Preserve notes, timestamps, and decision history
Keep approvals tied to the execution timeline
SOP docs & versioning
Keep process documentation connected to the workflow people actually run.
Nawfe lets you tie SOP documentation directly to a workflow, so the written process and the executable process stay aligned.
When the process changes, you can update the documentation, revise the workflow, review the new version, and publish it for future executions. Existing executions can continue running on the version they started with, while new executions follow the updated process.
That gives teams a safer way to improve processes without disrupting active work or losing track of which version was used.
With SOP docs and versioning, you can:
Attach process documentation directly to a workflow
Keep SOP instructions connected to the steps people actually run
Update documentation and workflow logic together
Create new versions as processes evolve
Review changes before publishing them
Publish approved updates for future executions
Let active executions continue on their original version
Preserve historical context for audits and reviews
Execution audits
Know exactly what happened in every process execution.
Every live run of a Nawfe process creates an execution history in real time. The workflow does not disappear when the work is done. It becomes a record of what happened.
See who owned each step, when it became available, when work was started, when it was completed, what information was submitted, what files were uploaded, and what decisions were made.
Nawfe does not just show that a step was completed. It can show when the step became available, when someone engaged with it, and when it was completed — giving teams a clearer picture of where time was spent and where work got stuck.
That makes it easier to review completed work, investigate delays, prepare for audits, and prove that the process was followed.
With execution audits, you can:
See the full timeline of a workflow execution
Track owners, timestamps, submissions, files, notes, and decisions
Review when steps became available, engaged, and completed
Preserve approval and review history
Understand where delays or handoffs occurred
Support compliance reviews and internal audits
Prove which process version was used
Keep a record of the work from start to finish
Dashboards & reporting
See what's moving, what's stuck, and what needs attention at a glance.
Nawfe dashboards help teams monitor active workflows without chasing status updates.
Track active executions, overdue steps, pending approvals, completed work, blocked handoffs, and process activity from one place. Leaders can see where work stands, which steps need attention, and where repeatable processes are slowing down.
That gives your team operational visibility while the work is still happening — not just after the process is complete.
With dashboards and reporting, you can:
View active, completed, delayed, or overdue executions
See pending approvals and open assignments
Track workflow status by process, owner, team, workspace, or date
Identify stalled handoffs and overdue steps
Monitor completion volume and process activity
Understand where work is slowing down
Give leaders visibility without manual status chasing
Workspace structure
Organize processes around the way your company works.
Workspaces are where your processes, users, and teams live.
Use workspaces to organize Nawfe by department, location, client group, project environment, operating unit, or business function. Invite the right users, group them into teams, and give each workspace the processes it needs.
Users can belong to multiple teams and multiple workspaces, giving your organization the flexibility to support cross-functional work without losing structure.
With workspace structure, you can:
Organize processes by department, location, client, function, or business unit
Invite users to the workspaces where they need access
Create teams that own steps, approvals, or process areas together
Add users to multiple teams when they support more than one function
Invite users to multiple workspaces when their role crosses operating areas
Support both focused team workflows and cross-functional processes