Low Code Integration Design

Orientation Low Code Integration Design covers the structural and operational decisions required to connect a low-code application to external systems, services, and data stores. It matters when a citizen-built or professional-grade app needs to read from or write to REST endpoints, SQL databases, message queues, or legacy terminals without writing custom server-side code from scratch. This page is not about UI construction, governance policies, licensing, or AI model invocation. It is about the integration layer: how connectors are defined, how data transforms as it passes between systems, how errors are detected and resolved, and what reliably breaks when a prototype graduates to production.

Connecting to External REST APIs

Defining a Connector

Most low-code platforms expose a connector configuration object that abstracts the HTTP client. The minimum required keys typically include base_url, timeout_ms, and response_format. Omitting timeout_ms often results in the platform defaulting to a 60-second blocking wait, which can lock the execution thread in a workflow and appear as a hang rather than a failure.

{
  "name": "CustomerLookup",
  "type": "rest",
  "base_url": "https://api.example.com/v1",
  "timeout_ms": 8000,
  "response_format": "json"
}

If the platform requires explicit header configuration, the headers key accepts a key-value map. A common omission is Accept: application/json; without it, some endpoints return XML by default, causing downstream mapping failures.

Supplying Authentication at the Integration Level

Integration-level authentication differs from user-facing auth patterns. Many platforms support API-key transmission via a dedicated api_key field or a headers.Authorization bearer token. The following configuration assumes a pre-issued API key stored in the platform’s secret store under the identifier EXTERNAL_API_KEY:

authentication:
  scheme: bearer
  token_ref: ${Secrets.EXTERNAL_API_KEY}

Some platforms additionally require tls_verify: true as a top-level key. Setting this to false to bypass certificate validation in dev environments frequently causes production failures when the deployment environment enforces strict mTLS or certificate pinning.

Handling Pagination and Rate Limiting

Cursor-based pagination is the most reliable pattern. The connector configuration typically expects pagination.cursor_param and pagination.next_url_path. If these are left unspecified, the platform may default to offset-based pagination, which breaks under concurrent workflow runs and can trigger 409 Conflict errors from the downstream API.

Rate limiting is often configured with rate_limit.max_calls and rate_limit.per_seconds. When these are absent, the platform issues requests as fast as the workflow engine permits, and the external service responds with 429 Too Many Requests. The integration then silently retries with exponential backoff only if the platform’s built‑in retry policy is enabled; otherwise, the workflow fails with an unhandled HTTP error.

Integrating with Relational Databases

Connection Configuration

Database connectors require a dsn (data source name) or its decomposed equivalents: host, port, database, username, and password. The sslmode key is frequently confused with tls_verify. Setting sslmode: allow permits unencrypted traffic, which most production environments reject with SSL connection error: certificate verify failed. The correct production value is typically sslmode: verify_full or sslmode: require, depending on the platform’s dialect.

postgres://user:[email protected]:5432/appdb?sslmode=verify_full

Upsert Patterns

Upsert (insert-or-update) logic is commonly expressed via a platform‑specific expression or a raw SQL block. In many low-code environments, the following SQL template is supported:

INSERT INTO customers (id, name, email, updated_at)
VALUES (@id, @name, @email, now())
ON CONFLICT (id) DO UPDATE
SET name = EXCLUDED.name,
    email = EXCLUDED.email,
    updated_at = now();

If the platform auto‑generates the primary‑key conflict clause, omitting the RETURNING clause can cause the workflow to complete without confirming whether the row was inserted or updated, which matters for downstream idempotency checks.

Data Mapping and Transformation

JSONata Expressions

Data that flows between a REST API and a database often requires reshaping. JSONata is supported by several platforms as a concise mapping language. The following expression renames a nested field and filters by status:

{
  customerId: $.data.id,
  customerName: $.data.attributes.first_name + " " + $.data.attributes.last_name,
  active: $.data.attributes.status = "active"
}

A frequent silent failure occurs when a field in the source payload is null rather than missing. JSONata returns null for both cases, but the downstream database column may reject null if a NOT NULL constraint exists, causing the integration to abort with a schema validation error. Adding a default with the // operator prevents this:

active: $.data.attributes.status // "inactive"

JavaScript Code Components

When JSONata cannot express the required logic, most platforms allow a small JavaScript snippet embedded in the mapping configuration. The following snippet normalizes a date string and caps a numeric field:

// Map and sanitize incoming payload
return {
  normalizedDate: new Date(payload.created_at).toISOString(),
  cappedScore: Math.min(payload.rating, 5).toFixed(2)
};

A common edge case is timezone handling. If payload.created_at is a string like "2024-03-15T14:30:00Z" and the platform runs in a UTC‑less runtime, new Date() may interpret it in the local timezone, producing an offset‑shifted timestamp. Explicitly passing "Z" or using Date.UTC() prevents this.

Error Handling and Monitoring

Recognized Error Texts

Integration failures manifest as specific HTTP or database error strings. The following are observed across multiple platforms when a connector misconfiguration occurs:

• ECONNREFUSED 127.0.0.1:5432 – The database host or port is unreachable; verify the DSN and network policies.
• 401 Unauthorized - Invalid bearer token – The authentication.token_ref points to a secret that has expired or is incorrectly referenced.
• 403 Forbidden - Insufficient scopes – The API key has valid syntax but lacks the required scope for the requested endpoint.
• 429 Too Many Requests - retry-after: 60 – Rate limiting is active; the platform must honor the Retry-After header or apply a configured backoff.
• Connection timeout after 30000ms – The timeout_ms value was either omitted or set too low for the network latency of the target.

Retry and Circuit Breaker Configuration

Most platforms expose retry.max_attempts and retry.backoff_ms. Setting retry.max_attempts: 0 disables retries, which is appropriate for idempotent idempotency‑key‑protected writes but dangerous for non‑idempotent operations like fund transfers. A circuit‑breaker threshold, when available, is set via circuit_breaker.failure_threshold: 5, after which the connector pauses calls for a cooldown period defined by circuit_breaker.cooldown_ms.

Sharp Edges and Production Gotchas

Silent Failures That Mask Themselves as Success

• Empty 200 OK with no body: Some APIs return 200 OK with an empty JSON object {} on successful idempotent writes. The low-code workflow records this as success, but no data is persisted downstream, leading to lost records that surface only during audits.
• Partial payload transformation: If a mapping expression references a key that exists in the source but holds null, and the target schema marks the column as NOT NULL, the platform may silently coerce null to 0 or "" depending on the database dialect, corrupting data without raising an error.
• Webhook callback URL mismatch: When a low-code platform posts a webhook to an external endpoint, it expects the endpoint to respond with 200 OK within the platform’s configurable webhook.timeout_ms (default often 10 seconds). If the endpoint returns 202 Accepted without a body, the platform may retry the callback, causing duplicate processing.

Confused Options

• run_in_sandbox vs deploy_to_production: Many platforms have a run_in_sandbox flag that disables secret access and uses mock data. Copying a workflow from sandbox to production without toggling this flag results in 401 Unauthorized errors because the connector attempts to read secrets that do not exist in the production secret store.
• authentication.scheme: basic vs bearer: Basic auth transmits credentials in base64 on every request; bearer token auth typically uses a pre‑issued JWT. Mixing the two in the same connector configuration causes the platform to send the bearer token as a Base64‑encoded string in the Authorization header, which the API rejects with 401.

Deployment and Operations Gotchas

• Secret rotation without workflow update: If the API key or database password is rotated in the secret store, existing running workflows continue to use the cached secret until the workflow engine is restarted or the connector is re‑initialized. This creates a window where failures appear random.
• Connection pool exhaustion: Database connectors often pool a fixed number of connections (default 5–10 per workflow). High‑cardinality workflows that each open a new connection without closing it trigger PQ: too many connections, which surfaces as ECONNREFUSED for subsequent runs. Setting pool.max_connections: 20 and ensuring each query step completes and releases its handle mitigates this.

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.