Maple: an open-source observability platform built with Tinybird's TypeScript SDK

About the company

Maple is an open-source observability platform built on OpenTelemetry. It collects, visualizes, and analyzes distributed traces, logs, and metrics from your services, with AI-powered diagnostics. Queries run over billions of rows in milliseconds, powered by Tinybird's managed ClickHouse® infrastructure. Maple was built by David Granzin, a Senior Systems Engineer at Superwall, where he manages roughly 100 materialized views across their own ClickHouse clusters.

Problem

David manages roughly 100 materialized views at Superwall. He knows firsthand what it costs to run ClickHouse at scale: no visibility into dependencies, no staging environment, and schema changes that feel like high-wire acts. He'd been wanting to build an observability platform for two to three years, but standing up another ClickHouse cluster on his own time was a non-starter.

Why Tinybird

David first used Tinybird two years ago on a web analytics project. The DX contrast with raw ClickHouse stuck with him. When Tinybird added local-first development, self-hosting, and the TypeScript SDK, it removed the barrier entirely: all of ClickHouse's power, none of the operational overhead.

Results

• ~40% faster time to ship: 7 weeks from zero to production, compared to an estimated 12 weeks without Tinybird
• Zero infrastructure to manage: no cluster to provision, no ingestion pipeline to build, no API layer to maintain
• Two projects shipped simultaneously: built Maple's observability backend and Hazel's audit log infrastructure in the same stretch of time
• AI agents accelerated development: the TypeScript SDK made Tinybird resources readable and modifiable by AI coding agents

David knows ClickHouse, and what it costs to manage it

David isn't someone who read about ClickHouse's limitations in a blog post. He lives them daily at Superwall. When your team is responsible for 100+ materialized views, every schema change becomes a high-stakes operation. There's no built-in way to visualize how data flows through your views, no way to trace what depends on what, and no staging environment to validate changes before they hit production.

That experience shaped exactly what David needed for Maple. He didn't want to trade one operational burden for another. He wanted the query engine he already trusted, wrapped in tooling that would let him move fast without the anxiety of managing infrastructure on his own time.

Tinybird removed the barrier to starting

When David first tried Tinybird two years ago, it was a cloud-only product. He liked the DX but went back to raw ClickHouse for other work. What brought him back was the addition of local-first development and self-hosting. As an open-source enthusiast, being able to run Tinybird locally and iterate without deploying to the cloud on every change was a major unlock. It meant he could treat Tinybird the same way he treats the rest of his development stack: local iteration, fast feedback loops, no context switching to a cloud console.

David started building Maple in January, and shipped it to production seven weeks later. An open-source observability platform built on OpenTelemetry that ingests metrics, logs, and traces, all powered by Tinybird under the hood for storage and queryable API endpoints.

That's not a marginal improvement. That's the difference between a side project that ships and one that stalls out.

Schema visualization and branches made iteration safe

The Tinybird capabilities that mattered most to David weren't about raw performance (ClickHouse already delivers that). They were about the developer experience layer that makes ClickHouse practical to build on and iterate with.

At Superwall, David's team has no visibility into how their 100+ materialized views relate to each other. A schema change requires manually tracing dependencies and hoping nothing breaks. Tinybird solves this with built-in visualization of your data flow, making it immediately clear what depends on what.

Branches were equally important. David could spin up an isolated environment, test schema changes, validate query performance, and iterate without touching production. For a side project where there's no QA team and no safety net, this is the difference between shipping confidently and shipping scared.

David also highlighted deployments as a key differentiator. He knows he's going to iterate heavily on Maple as he adds new features and computes new statistics. With Tinybird's deployment tooling, staging environments, and schema visualization, he can iterate with confidence instead of anxiety.

The TypeScript SDK accelerated development with AI agents

David started Maple before the Tinybird TypeScript SDK officially launched as one of the early beta testers. The SDK defines datasources, pipes, endpoints, and materialized views as TypeScript code, complete with type-safe ingestion, autocomplete for queries, and a CLI that feels like modern app development.

For David, the TypeScript SDK had a compounding effect: because his Tinybird resources were now defined in TypeScript, AI coding agents could read and modify them directly. He used agents extensively to iterate on queries, test different performance characteristics, and explore schema alternatives.

This is a pattern we're seeing more broadly: the TypeScript SDK turns Tinybird resources into something AI agents natively understand. Agents can read your data model, write endpoints, add materialized views, and fix schema issues because it's all just TypeScript. The previous .datasource and .pipe DSL files were opaque to these tools. TypeScript is their native language.

import { defineEndpoint, node, t, p } from "@tinybirdco/sdk";

export const topPages = defineEndpoint("top_pages", {
  params: {
    start_date: p.dateTime(),
    end_date: p.dateTime(),
    limit: p.int32().optional(10),
  },
  nodes: [
    node({
      name: "aggregated",
      sql: `
        %
        SELECT pathname, count() AS views
        FROM page_views
        WHERE timestamp >= {{DateTime(start_date)}}
          AND timestamp <= {{DateTime(end_date)}}
      `,
    }),
  ],
});

Fast enough to start a second project

One indicator of how much time Tinybird freed up: while building Maple, David also started Hazel, an open-source, AI-first business chat application designed as a modern replacement for Slack. For Hazel, he's using Tinybird to build a comprehensive audit log that tracks everything users and AI agents access, so organizations can trace exactly what was accessed and by whom.

With AI agents increasingly embedded in workplace tools, audit logging is becoming a critical requirement, not a nice-to-have. Organizations need to know what their AI agents looked at, what they extracted, and when. David built that entire audit infrastructure on Tinybird, alongside Maple, because Tinybird made it trivially fast to spin up a new project.

The fact that David could build the observability backend for Maple and the audit log infrastructure for Hazel in the same stretch of time speaks to how little friction Tinybird adds to a project. There's no cluster to provision, no ingestion pipeline to build, no API layer to maintain. You define your schema, write your SQL, and ship.

The developer experience gap that Tinybird fills

David has used managed ClickHouse offerings and self-hosted ClickHouse extensively. His perspective on what's missing from those alternatives is informed by years of hands-on experience at production scale.

The gap isn't about query performance or uptime. It's about everything around the database that determines how fast you can build and evolve your data architecture. Schema visualization. Branches for safe iteration. Observability over your own data pipelines. Deployment tooling with staging environments. A local development experience that fits into modern workflows.

These are the tools that let a solo developer manage the same level of ClickHouse complexity that gives full teams at companies like Superwall a hard time. Tinybird gives David the same ClickHouse engine he already knows, wrapped in the developer experience that makes it practical to build complex data architectures, whether you're a team of 50 or a solo builder shipping on nights and weekends.

What David built

Maple is an open-source observability platform built on OpenTelemetry. It collects, visualizes, and analyzes distributed traces, logs, and metrics from your services, with AI-powered diagnostics. Queries run over billions of rows in milliseconds, powered by Tinybird's managed ClickHouse infrastructure.

Hazel is an open-source, AI-first business chat application designed as a modern replacement for Slack. It uses Tinybird to power comprehensive audit logging for tracking user and AI agent access across the platform.