Enabling Multi‑Branch Collaboration on Low‑Code Platforms

Introduction

With the rise of low‑code, building enterprise applications on low‑code platforms has become a production trend, and increasingly complex apps are being created on these platforms. Developers face scenarios such as multi‑person collaboration, parallel development, and maintaining multiple versions, but existing platforms provide weak support, leading to high collaboration costs and limited iteration efficiency.

Based on low‑code related protocols, we designed a multi‑branch collaborative development solution to reduce coordination cost and improve R&D efficiency.

Why Multi‑Person Collaboration Is Needed

User research on an internal low‑code platform revealed strong demand for better collaborative and multi‑branch capabilities, which are major concerns and pain points.

Current Problems

When a page is split between two developers, one must finish before the other can start.

Urgent online bug fixes require a rollback, then a full redevelop of new features.

Parallel feature development forces copying pages and manual schema merging.

These lead to three core issues:

No parallel development support , causing idle developers and limited collaboration.

No iteration mode , lacking isolation and raising iteration costs for fast‑changing business.

Unable to merge changes , requiring experts familiar with the protocol and increasing merge and verification cost.

Problem Analysis

Low‑code’s advantage is low cost and speed; a collaborative solution must not dramatically increase complexity. Key questions include how to “collaborate”, how to achieve multi‑version control, and how to keep the learning curve low for non‑code developers.

How to Achieve Multi‑Person Collaboration

We adopt a “soft‑hard” combined approach:

Soft (80% of parallel needs) : Reduce coupling by splitting granularity, using micro‑frontend or component decomposition so that different developers work on independent modules.

Hard : Design a robust branch‑management strategy similar to source‑code development, allowing developers to work on isolated branches and merge back to the main line.

Implementation Details

Platform Background

The target platform currently lacks solid collaborative support. Development follows a visual drag‑and‑drop workflow, with data stored in a database and published after testing.

Current Effects

Parallel Development : Support low‑code components, enabling page development to be split into reusable components.

Iteration Management : Developers create an iteration, work on an isolated branch, and merge back to the main branch when done.

Technical Implementation

1. Use Git for iteration management – Convert database metadata to an intermediate code format, store it in Git, and leverage Git’s distributed version control.

2. Simple branch strategy – Keep a single master branch; all feature branches are copies of master. Development occurs in an iteration branch, which is merged back to master and deleted after release.

Overall Process

Creating an application stores its data in the database and creates a corresponding Git repository. Creating an iteration copies the full data set, links a Git branch to the iteration version, and isolates data between iterations.

During daily release, data is converted from DB to Git, merged, conflicts resolved via WebIDE, then converted back to DB, packaged, and built.

Schema conversion transforms page schemas into JSX‑like code for easier conflict resolution and code review, then back to the original low‑code schema using Babel AST parsing.

Extensibility

The solution provides hooks (dbToGitHook, beforeGitToDbHook) for platforms to customize data submitted to Git or returned after merging, ensuring adaptability to different low‑code engines.

Visual Multi‑Branch Collaboration

Current prototypes show challenges such as unreadable conflicts, a sense of fragmentation when jumping to WebIDE, and lack of control over merged changes. The next steps include visual diff, visual code review, and visual merge tools that let users select retained changes via point‑and‑click.

Summary and Outlook

Future work will refine this solution into a standardized low‑code multi‑branch framework, delivering a collaborative experience that aligns with low‑code mental models.