Commit & Push

Nected’s Git Sync lets your team capture every change to Rules, Workflows, Datasets, Integrations, and Variables in Git. Commits are created directly from the Nected workspace, while code reviews, PR approvals, and merge conflict handling continue to be managed in Source Control.

This ensures a clean separation of responsibilities:

• Nected → Create commits, push changes, view diffs, track modifications

• Source Control Repo→ Review pull requests, validate changes, enforce branch protection, resolve conflicts, merge branches

Together, they provide a controlled, auditable workflow for decision automation development.

What Gets Tracked in a Commit

Every commit created from Nected includes the exact set of modified resources since the last push:

Tracked Resource Types

• Rules (Simple Rules, RuleSets, Versions)

• Workflows (nodes, triggers, nested workflows)

• Integrations (config changes, added connections)

• Datasets (schema updates, structure changes)

• Variables & Secrets (non-sensitive metadata only)

Credentials are never synced for security reasons.

GitHub File Structure

When you push from Nected, the connected GitHub repository is updated with a structured layout that reflects all Synced Entities. Each type of asset lives in its own top-level folder, so your team can browse the repo, inspect changes per entity, run diffs, and use standard Git tooling for review and CI. GitHub also shows the last commit message and timestamp per folder, so you can see when each area was last updated.

How Nected Organizes the Repository?

Nected writes synced assets into the repository in an entity-based structure at the root of the branch:

• One folder per entity type — Each Synced Entity type has a dedicated top-level directory. Changes are grouped by type, so commits and PRs stay readable and scoped.

• References preserved — Dependencies between entities (e.g. rule → dataset, workflow → connector) are stored as references, so structure and relationships are maintained across push and pull.

• Incremental updates — Only files that changed in a given push are updated; unchanged entities are left as-is, keeping history clear.

The exact folder names are determined by Nected. In your connected repository you will see a root layout similar to the following:

Folder	What it contains
rule	Rule and RuleSet definitions, including all versions (Draft, Staging, Published). Each rule or ruleset is represented so you can diff logic changes in GitHub.
workflow	Workflow definitions: nodes, triggers, nested workflows, and connections. Full workflow structure is versioned here.
dataSet	Dataset schemas and structure. Definitions and schema changes are synced; actual data is not stored in Git.
connector	Integration (connector) names and metadata only. No credentials, API keys, or sensitive configuration are written—only references used by rules and workflows.
credential	Credential references and non-sensitive metadata (e.g. names, types). Secret values are never exported.
variable	Global and secret variable names and non-sensitive metadata. Variable values are not stored in Git; they must be set in Nected per environment after a pull.
module	Module-related definitions that Nected syncs (e.g. reusable logic or components). Structure depends on your workspace usage.
module_schema	Schema or structure definitions for modules. Keeps module contracts and shapes under version control.
tag	Tag definitions used to organize or categorize rules, workflows, or other entities. Tagging metadata is synced so organization is consistent across branches and environments.

Inside each folder, Nected creates the files and subfolders needed to represent the entities. File naming and format are managed by Nected; you do not need to create or edit these files by hand—use the Nected UI to change logic, then commit and push.

What You Can Do With This Structure

• Review in GitHub — Open pull requests and use GitHub’s diff view to see exactly what changed in rule, workflow, dataSet, or other folders. The per-folder commit history in the repo root helps you spot which areas changed recently.

• CI/CD — Use GitHub Actions or other automation to run checks when specific paths change (e.g. run tests only when rule/ or workflow/ changes), validate file format, or trigger deployments.

• Audit — Use Git history to see who changed what and when, and to restore or compare past versions. Each folder’s last commit message and timestamp give a quick overview of recent activity.

• Branching — Each branch holds its own copy of this structure. Feature branches can evolve rules, workflows, and datasets independently; merge in GitHub, then pull in Nected to apply the result.

What Is Not in the Repository

The following are never synced to Git:

• Credentials and secret values — API keys, tokens, passwords, and any secret values. Only names and non-sensitive metadata (e.g. in credential and variable) are stored.

• Integration configuration and auth — Connector credentials and auth details stay in Nected; only connector references and metadata are in the connector folder.

• Variable and secret values — Variable and secret values are not in Git; only names and metadata. Configure values in Nected after each pull for the current environment.

• Schedulers — Schedules are not part of Git sync; they exist only in the Nected workspace and run on the default branch.

• Workspace settings, teams, and users — Not synced; manage these in Nected.

After a pull, re-attach or configure Integrations and secrets in Nected for the current environment. See Pull Changes for the Sync Integrations & Credentials step.

Pushing Changes (Commit & Push)

You can push changes either from the workspace-level push panel or from an individual rule/workflow editor.

1. From the Workspace Push Panel

1. Click Push in the bottom-left corner

2. Nected loads all pending changes since the last deploy/pull

3. You will see a summary like the screenshot.

4. Enter a commit message

5. Choose your commit method:

Commit Options

Option	Behavior
Commit and Push	Creates a standard commit and pushes to the remote branch
Force Push (Override and Push)	Replaces the remote branch version with your local workspace version

2. From an Individual Rule or Workflow

Inside a Rule or Workflow editor:

1. Click the ⋮ (more options menu)

2. Select Push to Git

3. Nected opens a push dialog scoped to that specific resource

4. Enter a commit message and push

This is useful when you want to commit one rule or workflow without touching workspace-wide changes.

Handling Push Conflicts

If Nected detects that your local workspace differs from GitHub:

Your options:

• Override and Push → Force your local changes into GitHub

• Discard Changes → Cancel the operation

GitHub remains the authority for merging logic. Nected does not handle conflict resolution itself. If the conflict requires code-level resolution, you must:

Resolve the conflict inside GitHub → Commit → Pull into Nected

Reviewing Changes (In GitHub)

Reviewing, approving, and merging changes into target branches is performed in GitHub, not in Nected.

This includes:

• Opening pull requests

• Reviewing diffs

• Adding comments

• Approving or rejecting PRs

• Checking CI/CD workflows (if configured)

• Enforcing branch protection rules

• Resolving merge conflicts

Nected only handles the commit creation and syncing, while GitHub remains the system of record for code review.

Once a pull request is merged:

1. Nected users click Pull

2. The updated state from GitHub is imported into the workspace

3. Local workspace items update accordingly

Best Practices for Commit & Review

• Commit small, isolated changes for cleaner diffs

• Use meaningful commit messages (e.g., “Add discount eligibility rule logic”)

• Always pull before starting new work to reduce conflicts

• Never bypass GitHub reviews if your team uses branch protection

• Use feature branches for experimental or risky logic