For engineering and data teams

Own the workflow.
Understand every run.

Moving orders, customer records, or reports between systems every day? Define the reads, SQL transforms, and writes in Git. Braidplane runs the pipeline and shows what completed, what failed, and where to investigate.

Create Alpha account Watch the demo

Sign up for Alpha evaluation with test data and non-production systems. Setup help is optional.

Explore how Braidplane works — no account or setup needed.

Your pipeline, end to endDefined in Git · Executed by Braidplane
Source
Read the data you need

Query connected systems and bring the results into your pipeline.

Walkthrough

Postgres supplies orders and customers.

output contract
Transform
Shape it with SQL

Join, filter, and reshape source data with SQL.

Walkthrough

SQL joins orders with customer details.

input contract
Sink
Deliver the result

Write transformed data to the destination your workflow needs.

Walkthrough

S3 receives a JSON file for each run.

Contracts check expected fields and types between steps. This walkthrough uses synthetic orders and customers; read and write support varies by connector.
Braidplane Alpha. For evaluation with test data and non-production systems. Features and data may change or reset. Do not connect production systems or provide production or sensitive data. There is no SLA.

From a definition to a finished run.

A synthetic example: read orders and customers from Postgres, join them with SQL, and check the JSON delivered to S3.

Recorded CLI walkthrough

Validate, run, and verify the delivered records in one minute.

Synthetic workflow recording 00:00
One pipeline.
The complete run. 
Loading recorded CLI walkthrough...
00:00
Loading local .cast

See how the pipeline is defined.

Two source reads, one SQL join, and one JSON write, with explicit data checks between steps.

  • SourceRead orders and customers from the selected connections.
  • TransformNative SQL maps the two row sets into joined order records.
  • SinkWrite joined orders to a JSON file in the destination.
Open the pipeline spec
metadata:   slug: golden-path-joined-orders  name: Golden Path Joined Orderssteps:   - kind: query    slug: fetch-paid-orders    name: Fetch paid orders    query:       data_source_ref: golden-path-orders-postgres      operation_type: sql      operation_ref: golden-path-orders      output_contract:         name: golden-path-paid-orders        representation: rows        fields:           - name: order_id            type: string            required: true          - name: customer_slug            type: string            required: true          - name: order_total_cents            type: integer            required: true          - name: discount_cents            type: integer            required: true          - name: net_total_cents            type: integer            required: true          - name: placed_at_utc            type: string            required: true  - kind: query    slug: fetch-active-customers    name: Fetch active customers    query:       data_source_ref: golden-path-customers-postgres      operation_type: sql      operation_ref: golden-path-customers      output_contract:         name: golden-path-active-customers        representation: rows        fields:           - name: customer_slug            type: string            required: true          - name: customer_name            type: string            required: true          - name: customer_segment            type: string            required: true          - name: region            type: string            required: true  - kind: transform    slug: join-orders-customers    name: Join orders to active customers    transform:       inputs:         orders: fetch-paid-orders        customers: fetch-active-customers      input_contract:         name: golden-path-join-inputs        representation: rows        fields:           - name: orders.order_id            type: string            required: true          - name: orders.customer_slug            type: string            required: true          - name: orders.order_total_cents            type: integer            required: true          - name: orders.discount_cents            type: integer            required: true          - name: orders.net_total_cents            type: integer            required: true          - name: orders.placed_at_utc            type: string            required: true          - name: customers.customer_slug            type: string            required: true          - name: customers.customer_name            type: string            required: true          - name: customers.customer_segment            type: string            required: true          - name: customers.region            type: string            required: true      sql: |        SELECT          orders.order_id AS order_id,          orders.customer_slug AS customer_slug,          customers.customer_name AS customer_name,          customers.customer_segment AS customer_segment,          customers.region AS region,          orders.order_total_cents AS order_total_cents,          orders.discount_cents AS discount_cents,          orders.net_total_cents AS net_total_cents,          CAST(orders.net_total_cents AS DOUBLE) / 100 AS net_total_amount,          orders.placed_at_utc AS placed_at_utc        FROM orders        JOIN customers ON customers.customer_slug = orders.customer_slug        ORDER BY placed_at_utc, order_id      output_kind: rows      output_contract:         name: golden-path-joined-orders        representation: rows        fields:           - name: order_id            type: string            required: true          - name: customer_slug            type: string            required: true          - name: customer_name            type: string            required: true          - name: customer_segment            type: string            required: true          - name: region            type: string            required: true          - name: order_total_cents            type: integer            required: true          - name: discount_cents            type: integer            required: true          - name: net_total_cents            type: integer            required: true          - name: net_total_amount            type: number            required: true          - name: placed_at_utc            type: string            required: true  - kind: sink    slug: write-joined-orders    name: Write joined orders to S3    sink:       idempotency_class: naturally_idempotent      input: join-orders-customers      input_contract:         name: golden-path-joined-orders-s3-input        representation: rows        fields:           - name: order_id            type: string            required: true          - name: customer_slug            type: string            required: true          - name: customer_name            type: string            required: true          - name: customer_segment            type: string            required: true          - name: region            type: string            required: true          - name: order_total_cents            type: integer            required: true          - name: discount_cents            type: integer            required: true          - name: net_total_cents            type: integer            required: true          - name: net_total_amount            type: number            required: true          - name: placed_at_utc            type: string            required: true      data_source_ref: golden-path-s3-sink      operation_type: s3      operation_ref: golden-path-s3-write-joined-orders      config:         key: runs/{{runtime.sink_replay_identity}}/joined-orders.json        format: json        content_type: application/json        metadata:           source: braidplane-golden-path          run: "{{runtime.run_slug}}"        overwrite: true
Data source refs Portable logical source and sink references keep credentials out of the spec.
Operation refs Source and sink steps call saved connector operations by slug.
Transform contracts Input and output contracts make each data edge explicit.
Run slug Run-scoped output keys keep artifacts tied to execution evidence.
The recording above and this spec describe the same joined-orders pipeline.
A real product view using synthetic data. Inspect the steps behind a run, then verify the delivered records in the destination, as shown in the recording. Open full-size screenshot.

Read the PostgreSQL-to-S3 walkthrough. Requires an Alpha account, the public CLI, and your own non-production resources.

Braidplane run inspection showing the synthetic joined-orders step graph and selected S3 write evidence.

Work with the systems you already use.

Databases, warehouses, APIs, and storage. One place to define the workflow between them.

Bring one workflow.
Explore it with us.

Need help with a non-production example? A scoping conversation is optional.

  1. Describe the job. Tell us what needs to move, between which systems, and what is difficult today.
  2. Scope a safe example. We help map the connections, define the pipeline, and reproduce the workflow with synthetic data.
  3. Agree what success means. Decide together which result and failure checks would make the evaluation useful.

Setup help and demos are optional.