DataWorks lets you enforce quality gates at key stages of the data development lifecycle — before a task runs, before a task is debugged, before code is committed, and before changes are published to production. Use built-in check items for common governance scenarios, or build custom check logic when your requirements go beyond what the built-in checks support.
Process management is available only in DataWorks Enterprise Edition and later.
How it works
DataWorks workspaces operate in either standard mode or basic mode. The development flow differs between modes, but both support process controls at the same key stages.
Development flow in a standard mode workspace
Development flow in a basic mode workspace
At each stage, DataWorks pauses the workflow and runs a control check before the next step proceeds. Two feature modules support all control stages:
| Stage | Data Governance Center | Open Platform |
|---|---|---|
| Pre-run | Supported | Supported |
| Pre-debug | Supported | Supported |
| Pre-commit | Supported | Supported |
| Pre-publish | Supported | Supported |
Choose your approach:
| Approach | Use when |
|---|---|
| Data Governance Center | The built-in check items cover your requirements. Enable a check item and DataWorks automatically runs the associated check logic — no custom code needed. |
| Open Platform | You need logic beyond the built-in checks, such as calling an external approval system, enforcing custom SQL quality rules, or implementing network access control for publishing. |
The following sections use a standard mode workspace as the reference scenario.
Enable built-in check items (Data Governance Center)
The Data Governance Center includes multiple built-in check items. Enable the ones relevant to your workflow, and DataWorks runs the associated check automatically. The development flow continues only after the check is complete.
To map check items to control stages, use the following check stage settings:
| Control stage | Check stage setting |
|---|---|
| Pre-run | Pre-run Event for Code |
| Pre-commit | Pre-commit Event for File |
| Pre-publish | Pre-publish Event for File |
Enable check items in the Data Governance Center and specify which workspace they apply to. For step-by-step instructions, see Configure administration items.
Build custom check logic (Open Platform)
Use Open Platform when the built-in check items don't meet your requirements — for example, when you need to call an external approval system, enforce custom SQL validation rules, or control network access during publishing. Open Platform provides three components that work together:
OpenEvent — subscribes to messages about user operations in Data Studio.
Extensions — hosts the custom check or approval logic you develop.
OpenAPI — sends the approval result back to DataWorks as a callback, allowing the workflow to continue or halt.
When a user performs a controlled operation in Data Studio, the following sequence runs:
DataWorks emits an event via OpenEvent.
Your extension receives the event and runs the check logic (for example, verifying against an external approval system).
The extension calls back via OpenAPI with the result.
DataWorks either allows the operation to proceed or blocks it, based on the callback result.
Event types by control stage
Subscribe to the relevant event types for each control stage:
| Control stage | Event types to subscribe |
|---|---|
| Pre-run | Pre-run Event for File |
| Pre-commit | Pre-commit Event for File, Pre-commit Event for Table |
| Pre-publish | Pre-publish Event for File, Pre-publish Event for Table |
For a complete list of subscribable event types, see Extensions overview.
Set up Open Platform controls
In Open Platform, subscribe to the Data Studio events you want to control.
Develop an extension that implements your check or approval logic. For instructions, see Develop and deploy an extension: self-built service.
Publish the extension to DataWorks and enable it in the target workspace.
For more on OpenEvent and Extensions, see OpenEvent overview and Extensions overview.
What's next
Explore best practices for common control scenarios: