bino sandboxHosted · freeNo account needed

Evaluate report as code in a browser tab.

The sandbox is the real bino toolchain behind a URL: write the manifests on the left, watch the IBCS report render on the right, upload your own CSV, and export the whole thing as a project that runs on a laptop and in CI. Nothing to install, nothing to procure.

  • No install
  • No account to start
  • Shareable by URL
  • Exports a runnable project

Editor and report, side by side

Both halves below are real: the file on the left is a live sandbox, and the page on the right is what its preview actually rendered — the same engine that produces the PDF, with the same IBCS discipline.

bino sandbox
report.yaml
Run
apiVersion: bino.bi/v1alpha1
kind: DataSource
metadata:
  name: new_cities
spec:
  type: csv
  path: https://sandbox.bino.bi/api/data/new_cities.csv
  delimiter: ";"
---
apiVersion: bino.bi/v1alpha1
kind: DataSet
metadata:
  name: revenue_by_city
spec:
  query: |-
    SELECT category, categoryIndex, operation,
           SUM(pp1) AS pp1, SUM(ac1) AS ac1
    FROM new_cities
    WHERE date = (SELECT max(date) FROM new_cities)
    GROUP BY category, categoryIndex, operation
    ORDER BY categoryIndex
  dependencies:
    - new_cities
---
apiVersion: bino.bi/v1alpha1
kind: DataSet
metadata:
  name: revenue_trend
spec:
  query: |-
    WITH monthly AS (
      SELECT CAST(date_trunc('month', CAST(date AS DATE)) AS DATE) AS month,
             SUM(pp1) AS pp1, SUM(ac1) AS ac1, SUM(fc1) AS fc1
      FROM new_cities
      WHERE date >= '2026-01-01'
      GROUP BY month
    )
    SELECT strftime(month, '%Y-%m-%d') AS date,
           'Total' AS category, 1 AS categoryIndex, '+' AS operation,
           pp1,
           CASE WHEN month <  DATE '2026-07-01' THEN ac1 END AS ac1,
           CASE WHEN month >= DATE '2026-07-01' THEN fc1 END AS fc1
    FROM monthly
    ORDER BY month
  dependencies:
    - new_cities
---
apiVersion: bino.bi/v1alpha1
kind: LayoutPage
metadata:
  name: dashboard
spec:
  pageLayout: 2x2
  titleBusinessUnit: Acme Corp
  titleMeasures:
    - name: Revenue
      unit: EUR k
  titleScenarios: AC, PY, FC
  titleDateEnd: "2026-06-30"
  titleDateFormat: month
  titleDateLink: interval
  footerText: Acme Corp - Monthly Sales Report
  children:
    - kind: ChartStructure
      metadata:
        name: region_chart
      spec:
        dataset: revenue_by_city
        scenarios:
          - ac1
          - pp1
        variances:
          - dac1_pp1_pos
        level: category
        order: ac1
        orderDirection: desc
        percentageScaling: 25
        chartTitle: Revenue by City
    - kind: ChartTime
      metadata:
        name: trend_chart
      spec:
        dataset: revenue_trend
        scenarios:
          - ac1
          - pp1
          - fc1
        level: category
        order: category
        orderDirection: asc
        dateInterval: month
        chartTitle: Monthly Revenue Trend
    - kind: Table
      metadata:
        name: region_table
      spec:
        dataset: revenue_by_city
        scenarios:
          - ac1
          - pp1
        variances:
          - dac1_pp1_pos
        type: sum
        sumTitle: Revenue by City
    - kind: Text
      metadata:
        name: summary
      spec:
        value: |
          **H1 2026 Summary**

          Total revenue reached **EUR 9.1m** year-to-date, slightly ahead of
          prior year at **+0.6%**. Madrid (**+2.1%**) and Amsterdam (**+1.8%**)
          grew fastest, while Seoul fell **-1.4%** vs PY.
Preview
A rendered IBCS dashboard page: revenue by city as a bar chart with variance to prior year, a monthly trend chart with forecast, a table and a written summary.
preview rendered

Rendered from this sandbox — the file on the left is the whole of it.Open this sandbox

Why it matters

The shortest distance between "show me" and a decision

Most reporting tools cost a pilot project before anyone can tell whether they fit. The sandbox costs a browser tab, and what comes out of it is the same definition your team would put in the repository.

Evaluate before you commit

A team can test whether report as code fits its monthly close in an afternoon — with its own numbers, and without an install, a licence or a ticket.

Every experiment is a link

A sandbox has a URL. Send it into a review and the room sees both the rendered report and the definition that produced it — no screenshots in slides.

No dead end

Export downloads the sandbox as a runnable bino project. What convinced the room goes straight into the repository; nothing gets rebuilt for production.

Onboarding that scales

New authors start from templates that already render, with autocompletion and live validation from the same language server the IDE uses — not a blank file and a wiki page.

How it works

Write, feed it your data, take it with you

A sandbox is one multi-document YAML file. Everything below is taken verbatim from the sandbox shown above — the same manifests bino builds from, with no sandbox-only dialect to translate afterwards.

One file source and two queries. The first shapes the latest month by city, the second turns the year into a monthly series where actuals hand over to forecast in July:

report.yamlyaml
apiVersion: bino.bi/v1alpha1
kind: DataSource
metadata:
  name: new_cities
spec:
  type: csv
  path: https://sandbox.bino.bi/api/data/new_cities.csv
  delimiter: ";"
---
apiVersion: bino.bi/v1alpha1
kind: DataSet
metadata:
  name: revenue_by_city
spec:
  query: |-
    SELECT category, categoryIndex, operation,
           SUM(pp1) AS pp1, SUM(ac1) AS ac1
    FROM new_cities
    WHERE date = (SELECT max(date) FROM new_cities)
    GROUP BY category, categoryIndex, operation
    ORDER BY categoryIndex
  dependencies:
    - new_cities
---
apiVersion: bino.bi/v1alpha1
kind: DataSet
metadata:
  name: revenue_trend
spec:
  query: |-
    WITH monthly AS (
      SELECT CAST(date_trunc('month', CAST(date AS DATE)) AS DATE) AS month,
             SUM(pp1) AS pp1, SUM(ac1) AS ac1, SUM(fc1) AS fc1
      FROM new_cities
      WHERE date >= '2026-01-01'
      GROUP BY month
    )
    SELECT strftime(month, '%Y-%m-%d') AS date,
           'Total' AS category, 1 AS categoryIndex, '+' AS operation,
           pp1,
           CASE WHEN month <  DATE '2026-07-01' THEN ac1 END AS ac1,
           CASE WHEN month >= DATE '2026-07-01' THEN fc1 END AS fc1
    FROM monthly
    ORDER BY month
  dependencies:
    - new_cities

The editor autocompletes kind values, the spec fields of each kind, enum values, dataset references and even the column names your query returns — and marks schema and lint problems as you type.

What you can render

From a single chart to the finished PDF

Preview a standalone component while you shape it, then wrap it in a layout page and a report artefact — all in the same file.

ReportArtefactDocumentArtefactLayoutPageTableChartStructureChartTimeTextTreeGridImage

Start from a template

Table

Blank sandbox

The minimal starter: the hosted sample CSV, a DataSet and a Table.

ChartStructure

Structure chart

Revenue by city as an IBCS bar chart with actual vs. prior-year variances.

ChartTime

Time series

Monthly revenue trend mixing actuals with a forecast for the rest of the year.

LayoutPage

Dashboard page

A 2×2 layout combining a structure chart, trend chart, table and commentary.

ReportArtefact

Full report (PDF)

The dashboard page wrapped in a ReportArtefact, ready for the PDF download.

Sharing & privacy

Share the link, keep the pen.

Edit rights are a capability held by your browser, not something the URL carries. That makes a sandbox safe to send around: a link is an invitation to look, not to overwrite.

Sharing a link

  • The share URL never carries the edit token — recipients get a read-only view.
  • Anyone can fork a sandbox into their own copy and edit that instead. The original is untouched.
  • Snapshots let you save a state you can restore or fork later.
  • Embed snippets are public, frozen snapshots — they do not follow later edits.

Keeping it to yourself

  • A sandbox appears in the public Explore feed only when you explicitly list it there.
  • With an account, a sandbox can be marked private — visible to you alone.
  • Accounts are optional and passwordless: a code by email, no password to manage.
  • A private sandbox is shared through a short-lived read link, not a permanent public URL.

Deployment

Our infrastructure, or yours

The public sandbox is free and stays free. Organisations that want their teams experimenting on internal numbers choose where the sandbox runs — we operate it, or you run it inside your own network.

Community

Public sandbox

Free

sandbox.bino.bi — open a tab and start writing.

  • Unlimited sandboxes, no account to start
  • Templates and a public Explore feed
  • CSV and Excel upload
  • PDF export and runnable-project download
Enterprise

Self-hosted / on-prem

On request

One binary plus a container runtime, in your own data centre or VPC.

  • A single Go binary with the web app embedded
  • Every render runs in its own container with CPU, memory and process ceilings
  • You decide which bino versions your teams may select
  • Confidential figures never leave your network
  • Container image and deployment support
It is the same bino either way
The sandbox runs the released bino CLI — the one your team installs, the one your pipeline runs. A sandbox is not a demo build with different behaviour; it is the product, hosted.

Technical detail

What your architects will ask before you send the link around

How the sandbox renders, what it isolates, and where the limits are.

The editor

  • Autocompletion for kind values, the spec fields of each kind, enum values, dataset and datasource references, and dataset column names.
  • Live schema and lint diagnostics, shown as squiggles while you type.
  • Both are driven by bino’s own language server — the same intelligence as the VS Code extension.
  • Engine errors surface in a console pane instead of a blank preview.
  • Switch the report language to see the rendered output in another locale.

Rendering

  • Each active sandbox runs its own bino preview; the app proxies its embedding endpoint.
  • Embeddings render self-contained, so the preview shows exactly what the build would.
  • Standalone components and full outputs alike: Table, ChartStructure, ChartTime, Text, Tree, Grid, Image, LayoutPage, DocumentArtefact, ReportArtefact.
  • A ReportArtefact builds a real PDF, rendered by the same engine as bino build.

Data

  • Upload a CSV or Excel file; a matching DataSource and DataSet are written into the editor for you.
  • Excel uploads carry the sheet name into the manifest.
  • Queries run as plain SQL in bino’s embedded engine.
  • An interactive builder can assemble the DataSet SQL step by step and keeps a log of what it did.
  • A hosted sample dataset is available to every sandbox, so a blank start still renders something.

Isolation & limits

  • Every bino invocation runs as its own container: its own filesystem, process tree, network namespace and cgroup.
  • Per-container ceilings — 1 GB memory, 1 CPU, 256 processes; PDF builds get 2 GB.
  • Removing a container takes the whole process tree with it, so nothing outlives a session.
  • Concurrent previews are capped; over the cap a preview answers 503 rather than degrading everyone.
  • Idle sessions are reaped after 10 minutes.

Sharing & persistence

  • Sandboxes persist at a stable URL and survive a closed tab.
  • Edit access is a bearer token minted on create or fork and kept in your browser — the share URL never contains it.
  • Snapshots can be restored or forked later.
  • Embed snippets are public, frozen snapshots and do not follow later edits.

Registry & runtime

  • Browse the public registry from the editor and add packages as dependencies — backed by real bino registry runs.
  • Installed packages behave like local documents, exactly as in a checked-out project.
  • Pick which bino version renders a sandbox, from the catalogue the deployment allows.
  • The catalogue reports the engine version behind each release, so you can reproduce an older render.

A sandbox for your organisation?

Tell us which teams should be experimenting and on what data. We will show you the shortest path — hosted by us, or running in your own network.