Getting Started

This section helps you understand what the Netgrif Platform is, its main components, and how to get started as a new user.

What is Netgrif Platform?

The Netgrif Platform is a process-based application platform designed for building and running business applications. It combines a process engine, a builder interface, a frontend framework, and powerful deployment tools into a single modular ecosystem.

It is ideal for organizations looking to:

• Model and run complex business processes
• Digitize workflows and automate case handling
• Manage users, permissions, and data in one environment

The platform is built around the Petriflow language, which enables visual and structured process modeling using Petri nets. This language provides a formal yet flexible way to define and execute workflows using transitions (actions), places (states), and arcs. The Netgrif Application Engine extends this model with rich business logic, conditions, role-based permissions, data operations, and automation - making it suitable for both simple forms and complex case-driven applications. Each defined workflow becomes a reusable process template from which individual cases are started and managed.

Core Concepts

Processes

A Process in the Netgrif Platform is a reusable definition of a workflow built using the Petriflow language. It models a business operation by defining:

• Tasks (transitions) users perform
• States (places) the case can be in
• Data fields required throughout the process
• Roles and permissions for access control

Each process acts as a template, from which individual cases (instances of the process) are started and executed.

Each process can generate many cases.

Cases

A running instance of a process. Each user works with active cases to complete tasks.

A Case is a single, running instance of a Process. When a user starts a process, the system creates a new case that contains all the data, tasks, and logic defined in the process template.

Each case tracks:

• Task progress - what has been completed, what's active
• Data values - user input, calculated fields, files, etc.
• User roles - who is responsible for each task
• History - full logs of every change and transition

Cases are:

• Stateful - they evolve over time as tasks are completed
• Traceable - every change is logged and reviewable
• Flexible - they can include sub-processes, event triggers, and role changes

In the Netgrif Platform, cases are the core of runtime behavior, enabling users to work through real business processes while the system enforces rules and automates logic behind the scenes.

Data Model

The data model in the Netgrif Platform defines all the fields that hold information within a process or case. These fields can include simple types like text, numbers, booleans, or more complex structures like lists, files, and nested objects. Each data field is bound to transitions (tasks) and used in forms, scripts, or conditions.

Data fields support:

• Validation rules, visibility settings and default values
• Dynamic calculations via expressions

Transitions and Tasks

A Transition is a core element of a process definition. It represents a logical step in the workflow, responsible for moving the case from one state to another. Transitions include all the backend rules - such as conditions (guards), actions (delegates), and data manipulations - that define the process flow.

A Task, on the other hand, is the user-facing representation of a transition. When a transition is available to a user (based on their role and the current process state), it is shown in the user interface as a task. Users interact with tasks to perform actions, provide input, and move the case forward.

Remember

Every task is based on a transition, but not every transition must be exposed as a task. Some transitions may be triggered automatically or by backend logic.

• When triggered, they perform Actions (more about Action api)
• Transitions are represented as Tasks in the UI (assigned to users or roles)
• Executing a task can change data, start subprocesses, trigger events, etc.
• Role-based access for viewing and editing

Applications

In the Netgrif Platform, Application Packaging is the process of bundling related processes, cases, and assets into a single deployable ZIP file. Each package includes a required manifest.xml file that describes the contents - such as processes, imports, dependencies, and metadata. This packaging ensures that all interconnected components are deployed and managed together, simplifying versioning, maintenance, and distribution across environments. More about applications and how to use them, you can read here.

Users and Roles

Roles and Permissions in the Netgrif Platform define who can access what in a process. Each process includes roles that control task visibility, data access, and user interaction. Permissions are enforced at every step - determining who can view, edit, or execute parts of a case. Roles can be assigned dynamically based on user input or data fields, allowing the process to adapt to real-life team structures and responsibilities as it evolves. The platform uses process roles and user groups to define who can perform actions or access data. more how to manage roles you can find here.

Main Components

Component	Description
Netgrif Builder	A web-based tool for designing processes visually
NAE (Engine)	Worker node that executes processes, manages cases, handles events
Admin App	UI for uploading, deploying, and managing applications and users
Frontend App	User interface where users interact with cases and complete tasks

First Steps

1. Open the Builder

   • Create or edit processes visually
   • Export processes for deployment as applications

2. Access the Admin App

   • Try trial application

3. Explore Applications

   • View applications management
   • Deploy sample applications

4. Start using

   • Navigate to your dashboard (Frontend App)
   • Launch a new case from any deployed process
   • Follow assigned tasks step-by-step