Building Enterprise Contract Management with Chengwu Low-Code: Approval, Versioning, Export in Days

Typical Challenges in Contract Management

In most enterprises, contracts face several pain points:

Chaotic approval processes : Workflows run via email/WeChat; nodes are skipped or assignees change without trace.

Content modifications leave no trace : Each change requires re-upload; versions are hard to manage, responsibility unclear.

Non-standard templates : Different business lines use varied formats; fields are filled arbitrarily.

Coarse-grained permissions : Everyone can view all contracts, risking leaks.

Rigid process logic : Once fixed, changing logic requires rewriting workflow engine code.

The low-code platform addresses these by making such logic modular .

Chengwu Low-Code Platform Capabilities

The platform offers features particularly suited for building an enterprise contract system:

Flexible data modeling (MySQL 8 + table comments + auto-generated CRUD)

LogicFlow workflow engine : supports conditional routing, role-based approval, approval history

Pebble template engine : dynamically builds contract content, approval notifications, process inputs

Fine-grained permission configuration : field-level, data-level, role-level access control

Template export support : auto-generates Word and PDF contract documents

Access URL:

https://admin.cwcode.top

System Module Structure

┌────────────────────┐
│   Contract Template Management │◄─── HR / Legal maintenance
└────────┬───────────┘
         │
         ▼
┌────────────────────┐
│   Contract Application/Editing │◄─── Employee initiation
└────────┬───────────┘
         │
         ▼
┌────────────────────┐
│   Approval Process Configuration │◄─── LogicFlow drag-and-drop design
└────────┬───────────┘
         │
         ▼
┌────────────────────┐
│   Contract Version Records │◄─── Auto-saved on each submission
└────────┬───────────┘
         │
         ▼
┌────────────────────┐
│   Contract Export & Archiving │◄─── Pebble renders Word/PDF
└────────────────────┘

Step 1: Database Modeling

Contract Information Table

CREATE TABLE contract (
  id bigint PRIMARY KEY AUTO_INCREMENT COMMENT 'Contract ID',
  title VARCHAR(100) COMMENT 'Contract Title',
  template_id bigint COMMENT 'Template ID',
  applicant_id bigint COMMENT 'Applicant ID',
  department VARCHAR(50) COMMENT 'Department',
  content TEXT COMMENT 'Contract Body (rich text)',
  status VARCHAR(20) COMMENT 'Status (Draft/Under Approval/Effective/Archived)',
  version int COMMENT 'Version Number',
  create_time datetime COMMENT 'Creation Time'
);

Step 2: Approval Process Orchestration (LogicFlow)

Supported configuration scenarios:

Amount < 50,000 → standard flow (Dept Manager → Legal)

Amount ≥ 50,000 → co-sign flow (Manager → Finance Director → Legal → General Manager)

Different template fields trigger different approval paths

Conditional Node Setup

Visual process diagram configuration:

[Submit Contract]
  ↓
[Judge Amount Range]
  ↓<50k          ≥50k↓
[Manager Approve]  [Manager Approve]
  ↓                  ↓
[Legal Approve]   [Finance Director] → [Legal Approve] → [GM Approve]
  ↓                  
[Archive/Notify]

Step 3: Building Contract Content & Notification Parameters with Pebble Templates

Contract Body Template (supports nested parameters)

Party A: {{ company_a }}  
Party B: {{ company_b }}  
Project Name: {{ project_name }}  
Contract Amount: ¥{{ contract_amount }}  
Start Date: {{ start_date }}  
End Date: {{ end_date }}  

After friendly negotiation, both parties sign this contract as follows:……

Contract template fields automatically generate input items in the frontend form; user fills them and the full contract content is rendered automatically.

Approval Notification Template (Pebble)

{
  "content": "You have a contract \"{{ title }}" from {{ applicant_name }} awaiting approval, amount: ¥{{ amount }}, please handle promptly."
}

Automatically pushed to DingTalk, WeCom, or system notification center.

Step 4: Version Retention & Export Archiving

Auto-generate version copy on each submission:

CREATE TABLE contract_version (
  id bigint PRIMARY KEY AUTO_INCREMENT,
  contract_id bigint,
  content TEXT,
  version int,
  created_at datetime
);

The platform automatically controls version numbers, diff comparison, and rollback functionality.

Export Word / PDF:

One-click export of contract content to Word (docx) and PDF (with watermark)

Templates can insert headers/footers, company logo, signature pages

Permission System Configuration

Regular Employee : Can only view self-initiated contracts; editable in draft state

Department Manager : Approval permission; can only view contracts within own department

Legal Specialist : Can view all contracts, approve, maintain templates

Admin/Platform : Full permissions: process config, template management, permission assignment, log viewing

Every field supports "read-only/hidden/editable" configuration, ensuring data isolation and sensitive field protection.

Launch Timeline & Delivery Efficiency

Data modeling + page generation : 1 day (SQL table creation + auto CRUD generation)

Process design & debugging : 1 day (LogicFlow drag-and-drop)

Template configuration : 0.5 day (Pebble contract template + notification template)

Permission & role control : 0.5 day (Visual permission configurator)

Word/PDF export integration : 0.5 day (Template filling engine + export module)

Total ~3-4 days to complete an MVP contract system deployment.

Conclusion: Contract System Is Not About Templates, It's About Process

The core of enterprise contract management is not stitching Word templates, but:

Make processes controllable, changes traceable, approvals auditable, exports unified.

Chengwu Low-Code, through data-driven design, workflow engine, and Pebble templates, turns a complex contract process into something as simple as "building blocks."