Low Code Data Modeling | The Garnet Wiki

Low code data modeling enables engineers and non-engineers alike to define, evolve, and manage data structures and relationships using visual tools and declarative configuration, without writing traditional code. It matters when teams need to rapidly prototype data schemas, align business and technical stakeholders on data requirements, or iterate on models in response to changing business logic—especially in environments where deployment cycles exceed weeks and database schema changes require migrations.

Defining and Structuring Entities

To model a new entity, open the data modeler and click "New Entity". A modal appears with fields: name, pluralName, description, isRoot, and primaryKey. The primaryKey field accepts a comma-separated list of column names. For example, to define a CustomerOrder entity:

{
  "name": "CustomerOrder",
  "pluralName": "CustomerOrders",
  "description": "Tracks orders placed by customers.",
  "isRoot": true,
  "primaryKey": "orderId, customerId"
}

The isRoot flag enables the entity to be a top-level resource in the API, accessible via /api/v1/customer-orders. When isRoot is false, the entity is used as a nested structure in other entities or as a lookup table.

Column Definition and Types

Each entity has a columns section. Click "Add Column" and specify:

name (required, camelCase or snake_case)
type (one of: string, integer, float, boolean, datetime, json, uuid, array)
nullable
default
index (list of indexes: unique, composite, fulltext)
validation (JSON object with rules)

Example:

{
  "name": "status",
  "type": "string",
  "nullable": false,
  "default": "pending",
  "index": ["unique"],
  "validation": {
    "enum": ["pending", "processing", "shipped", "delivered", "cancelled"],
    "minLength": 5,
    "maxLength": 20
  }
}

The validation object is validated at model load time. If status contains a value not in the enum, the platform logs:

Validation error: Column 'status' in entity 'CustomerOrder' has invalid value 'in transit'. Valid values: [pending, processing, shipped, delivered, cancelled]

Primary Key and Composite Keys

The primaryKey field is not just a list; it enforces order. If primaryKey is ["customerId", "orderId"], the database creates a composite key with customerId as the first column. Swapping the order leads to different index layouts and query performance—often silently affecting joins.

When adding a new column to a composite primary key, the platform does not automatically reindex. You must manually trigger "Rebuild Primary Key Index". Failure to do so leads to:

Error: Primary key constraint violation: Duplicate key (1001, 2005) already exists in CustomerOrder.

Defining Relationships

To link entities, use the "Add Relationship" button. Select a source entity, target entity, and choose the relationship type: one-to-one, one-to-many, many-to-one, many-to-many.

One-to-Many and Many-to-One

For Customer → CustomerOrder (one-to-many), the platform:

Creates a foreign key column customerId in CustomerOrder
Sets nullable: true on customerId
Generates the relationship metadata in relationships.json:

{
  "Customer": {
    "CustomerOrders": {
      "type": "one-to-many",
      "sourceColumn": "customerId",
      "targetEntity": "CustomerOrder",
      "cascadeDelete": true,
      "onDelete": "set null"
    }
  }
}

The cascadeDelete flag controls whether deleting a Customer also deletes all associated CustomerOrders. The onDelete value is one of: cascade, set null, restrict, no action.

Many-to-Many

For Product ↔ CustomerOrder, the platform:

Creates a junction table Product_CustomerOrder
Adds productId and orderId as foreign keys
Sets primaryKey to both columns
Generates a manyToMany block:

{
  "Product": {
    "CustomerOrders": {
      "type": "many-to-many",
      "junctionTable": "Product_CustomerOrder",
      "sourceColumn": "productId",
      "targetColumn": "orderId",
      "joinTable": {
        "primaryKey": ["productId", "orderId"],
        "indexes": ["unique"]
      }
    }
  }
}

The joinTable object is critical: if primaryKey is missing, the junction table does not enforce uniqueness, allowing duplicate associations. If indexes is omitted, the platform assumes [], leading to no index on productId or orderId.

Bidirectional Relationships

Bidirectional relationships are not automatic. You must explicitly set isBidirectional: true on the relationship definition. Without it, Customer.orders returns the list of orders, but CustomerOrder.customer returns null even when customerId is set.

Advanced Configuration and Constraints

Custom Constraints and Triggers

Use the "Add Constraint" feature to define SQL-level constraints. Enter raw SQL or use a declarative format:

{
  "name": "order_total_check",
  "type": "check",
  "expression": "total > 0 AND currency IS NOT NULL",
  "on": "CustomerOrder"
}

This generates a CHECK (total > 0 AND currency IS NOT NULL) constraint in the database. If total is null, the constraint fails silently until a CREATE TABLE migration is applied.

Index Optimization

Indexing is not just a checkbox. The platform allows per-index configuration:

{
  "name": "idx_customer_order_status",
  "type": "b-tree",
  "columns": ["status", "createdDate"],
  "where": "status IN ('processing', 'shipped')",
  "concurrently": true
}

The concurrently flag triggers CREATE INDEX CONCURRENTLY, which is critical in production. If concurrently is false, the index builds with a table lock, blocking writes during migration.

Schema Versioning and Diffing

Each data model has a version field. On save, the platform generates a schema-diff.json file:

{
  "fromVersion": "1.2.0",
  "toVersion": "1.3.0",
  "changes": [
    {
      "type": "add-column",
      "entity": "CustomerOrder",
      "column": "trackingNumber",
      "type": "string",
      "nullable": true,
      "default": null
    },
    {
      "type": "alter-column",
      "entity": "Customer",
      "column": "email",
      "type": "string",
      "length": 255
    },
    {
      "type": "add-relationship",
      "source": "Customer",
      "target": "Address",
      "type": "one-to-many",
      "relationshipName": "addresses"
    }
  ]
}

This file is consumed by the migration engine. If the migration fails, the platform logs:

Migration failed: Cannot apply schema-diff.json: Missing column 'trackingNumber' in table 'CustomerOrder'.

Common Pitfalls and Silent Failures

Default Values Are Not Applied at Runtime

When a column has a default value, the platform generates a DEFAULT clause in the CREATE TABLE statement. But default values are not applied during data import or API creation unless explicitly enabled.

If default: "pending" on status, and a new CustomerOrder is created via API without status, the status field is null in the database, not "pending". To fix, enable "Apply Defaults on Insert" in the entity configuration.

Foreign Key Constraints Are Not Enforced by Default

The platform generates FOREIGN KEY constraints from relationships, but they are not enabled by default. You must set enforceForeignKey: true in the entity configuration.

Without it, a CustomerOrder can reference a non-existent Customer, and no FK constraint error is raised. The ON DELETE behavior is also ignored unless enforceForeignKey is true.

Missing Indexes on Join Columns

A common failure: a one-to-many relationship is defined, but the customerId column in CustomerOrder has no index. The platform does not auto-create indexes on foreign key columns.

To fix, use the "Add Index" wizard and select "Index on Foreign Key". The wizard generates:

{
  "entity": "CustomerOrder",
  "columns": ["customerId"],
  "name": "idx_customer_order_customer_id",
  "type": "b-tree",
  "unique": false,
  "concurrently": true
}

If concurrently is false, the index build blocks all writes for minutes or hours.

Validation and Migration Drift

When a model is updated, the platform generates a migration script, but it does not validate the migration script against the current database state.

Example: CustomerOrder has status as string(20), but the migration script sets status as string(10). The platform logs:

Migration warning: Column 'status' in entity 'CustomerOrder' expected length 20, but schema has 10.

This drift causes runtime errors when inserting strings longer than 10 characters.

Relationship Name Inconsistencies

Relationships use name and relationshipName fields. The name is used internally (e.g., Customer.orders), while relationshipName is used in APIs and metadata.

If relationshipName is orderList, the API endpoint becomes /api/v1/customers/{id}/orderList. But the name field is used for Customer.orders—a mismatch that leads to confusion in documentation and client code.

The platform does not auto-sync name and relationshipName. You must explicitly set both.

Best Practices

Always enable "Apply Defaults on Insert" for entities with default values.
Use concurrently: true for all indexes in production.
Set enforceForeignKey: true on all entities that participate in relationships.
Use schema-diff.json to track changes and validate migrations.
Define validation rules for every string and enum column.
Use pluralName for API resource paths and documentation.
Name relationships explicitly: orders, addresses, lineItems—not orderList, addressList.

The data model is not a document. It is a live configuration that drives schema, API, validation, and performance. When it fails, it fails silently—until a status column has a null value, or a CustomerOrder points to a non-existent Customer, or a many-to-many join table contains duplicates. Low code data modeling is not just drag-and-drop; it is precision configuration.

This page was rewritten on 10 October 2026. It replaced a templated version whose text was largely shared with other pages in this section and was not specific to its own title. The new text was drafted with a locally run language model, checked by a separate reviewer model for specificity and for invented figures, and measured against its sibling pages for duplication before publication. If anything here is wrong, tell us at [email protected] and we will correct it.