# How to Vibe Code Your Own Axiom (and Stop Paying for It)

> The modern machine data platform

- Site: https://axiom.co
- Category: Observability & Machine Data Platform
- Platforms: Web app
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 2-3 weeks of focused development

## Verdict

You can build a personal log-analysis subset with Next.js, ClickHouse, and an MCP server, but you will skip petabyte-scale custom compression.

Rebuilding Axiom's proprietary multi-tenant EventDB, extreme columnar compression, and global edge ingest routing requires a dedicated systems engineering team. However, building a personal-use observability tool that ingests OpenTelemetry spans and logs into a ClickHouse or SQLite backend, queries them via a simplified APL interpreter, and exposes them to local AI agents via an MCP server is a rewarding and achievable project for a solo developer using AI coding agents.

### What you can't replicate

- Proprietary EventDB columnar storage and custom dictionary-encoding compression engine
- Petabyte-scale global multi-region edge ingestion routing infrastructure
- Enterprise compliance certifications (SOC 2, HIPAA BAA)

## What it does

Petabyte-scale, schema-less event store and observability platform for ingesting, querying, and storing logs, traces, and metrics without traditional indexing costs.

### Core features

- Schema-less event ingestion API (JSON / OpenTelemetry)
- APL (Axiom Processing Language) time-series query engine
- Dataset management library with field inspectors
- Interactive query editor with visualization builder
- Dashboard creation and real-time alerts
- Model Context Protocol (MCP) server for AI agent querying

## The business

### Pricing

- Personal: $0 / month
- Axiom Cloud: $25 / month

### Funding

$41.4M raised.
- Seed Round: $4M (June 2020)
- Series A and subsequent extensions
Investors: Crane Venture Partners, LocalGlobe, Fly Ventures, Mango Capital, Nat Friedman, Adam Wiggins

Founded 2020.
Team size: 20–60.

## The hard parts

- Writing a custom lexer and query planner for a piped time-series language (APL)
- High-throughput concurrent log ingestion pipeline handling unstructured payloads
- Columnar compression and storage layout over object storage (S3/R2)
- Stateful Model Context Protocol (MCP) server integration for local developer tooling

## How to vibe code Axiom

### Prerequisites

- Node.js (free): Runtime environment for Next.js web application and local MCP server execution.
- GitHub (free): Source code repository and continuous deployment integration.

### Recommended AI tools

- Claude Code: Best-in-class coding agent for scaffolding complex backend data pipelines and MCP servers.
- Cursor: Ideal AI-native editor for rapidly assembling the dashboard UI and query builder components.

### Stack

- Frontend: Next.js with Tailwind CSS, TanStack Table, and Monaco Editor for query editing
- Backend: Next.js API Routes and Node.js custom MCP server runtime
- Database: ClickHouse Cloud for high-performance event analytics storage
- Auth: better-auth for secure self-hosted personal authentication
- Payments: None required (personal-use project)
- Other: OpenTelemetry JS SDK for log/trace ingestion simulation, Zod for schema validation

### Hosting

- Vercel (Hosting the Next.js frontend and query dashboard interface): $0/mo (Hobby Tier)
- ClickHouse (Managed columnar event database backend for logs and traces): $0-10/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize a Next.js project with Tailwind CSS and configure connection to ClickHouse for high-speed event storage.

```
Create a new Next.js project using TypeScript and Tailwind CSS. Set up a ClickHouse database client connection using @clickhouse/client-web or standard HTTP client. Define the core 'events' table schema supporting flexible JSON attributes, timestamp, dataset name, and log levels. Implement a robust database migration script to initialize datasets table and sample indexes.
```

2. **Schema-less Ingestion API** — Build ingestion endpoints compatible with JSON payloads and OpenTelemetry format to load logs and traces.

```
Build a high-performance ingest API route at POST /api/datasets/[dataset]/ingest that accepts single JSON objects or newline-delimited arrays of log events. Validate incoming payloads, extract common metadata fields into typed columns, store raw JSON in a string column for schema-less flexibility, and bulk-insert into ClickHouse. Include error handling for malformed payloads and rate limiting.
```

3. **APL Query Engine & Parser** — Implement a lightweight APL (Axiom Processing Language) parser that translates piped queries into ClickHouse SQL.

```
Create an APL query compiler utility in TypeScript. The compiler must parse piped query strings like `['dataset'] | where status >= 500 | summarize count() by route | sort by count desc` and translate them into valid SQL queries executable against ClickHouse. Support basic operators: where, summarize, extend, sort, take, and bin_auto.
```

4. **Dataset Explorer & Query UI** — Construct the web interface featuring a dataset library, Monaco query editor, and tabular results view.

```
Build a React dashboard layout with Tailwind CSS mimicking an observability console. Include a sidebar listing datasets with event counts, a Monaco editor integration for writing APL queries with syntax highlighting, a Run/Cancel execution action, and a dynamic results table using TanStack Table that renders formatted JSON logs and aggregated metrics.
```

5. **Model Context Protocol (MCP) Server** — Develop a native MCP server allowing AI coding assistants like Claude Code to query logs and traces directly.

```
Implement a Model Context Protocol (MCP) server using the official TypeScript SDK that exposes tools for inspecting datasets, running APL queries, and fetching recent error logs. Ensure the server connects securely to your ClickHouse backend so coding agents in your terminal can investigate incident telemetry directly.
```

### Cost vs paying

**Starting costs (one-time):**

- AI coding assistant subscription (Claude Pro / Cursor): $20
- Total: ~$20 one-time

**Ongoing costs (monthly):**

- ClickHouse Cloud / hosting compute: $0 - $10/mo
- Total: ~$0 - $10/mo

- Paying for the SaaS instead: $25/mo + usage
- Build time: 35-50 hours
- AI tool credits: $20
- Break-even: N/A (Personal project for learning and local tooling)

## Sources

- [Axiom Official Website](https://axiom.co)
- [Axiom Pricing Documentation](https://axiom.co/pricing)
- [TechCrunch / Axiom Seed Announcement](https://axiom.co/blog/axiom-raises-7m-to-cure-data-headaches)