How to vibe codeAxiom
The modern machine data platform
axiom.co ↗Observability & Machine Data Platform
The verdict: can you vibe code Axiom?
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.
Estimated effort: 2-3 weeks of focused development
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)
Founded
2020
Raised
$41.4M
Team
20–60
Cheapest paid tier
$0 / month
What Axiom 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 from Crane Venture Partners, LocalGlobe, Fly Ventures, Mango Capital, Nat Friedman, Adam Wiggins
Pay vs build, cumulative
Break-even at month 2 — after that, every month is money kept.
The hard parts of vibe coding Axiom
- 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 vibecode Axiom
Prerequisites
Node.jsfree
Runtime environment for Next.js web application and local MCP server execution.
GitHubfree
Source code repository and continuous deployment integration.
AI coding tools
Recommended 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 & infrastructure
| 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
01Project 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.02Schema-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.03APL 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.04Dataset 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.05Model 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 for Axiom
What will you build it with?
Starting total with Claude Code$0 one-time
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 Axiom
$25/mo + usage
Your time to build
35-50 hours
AI tool credits
$20
Break-even
N/A (Personal project for learning and local tooling)
Vibe code Axiom: FAQ
- Can you vibe code Axiom yourself?
- Solid side project — 68/100 vibecodeable. You can build a personal log-analysis subset with Next.js, ClickHouse, and an MCP server, but you will skip petabyte-scale custom compression.
- How long does it take to vibe code Axiom?
- 2-3 weeks of focused development — roughly 35-50 hours of hands-on time with an AI coding agent.
- How do you build your own Axiom?
- Scoped to personal use: Next.js with Tailwind CSS, TanStack Table, and Monaco Editor for query editing on the front, Next.js API Routes and Node.js custom MCP server runtime behind it, ClickHouse Cloud for high-performance event analytics storage for data. Follow the 5-step build guide on this page — each step has a paste-ready prompt for an AI coding agent.
- How do you code your own Axiom without being an expert?
- Use an AI coding tool (Claude Code or Cursor) and work in small steps: scaffold, data model, core screens, then deploy. Realistic effort: 2-3 weeks of focused development. The prompts on this page are written so the AI does the heavy lifting.
- How much does it cost to vibe code Axiom instead of paying?
- About ~$20 one-time to start and ~$0 - $10/mo to run, versus $25/mo + usage for Axiom. Break-even: N/A (Personal project for learning and local tooling).
- What stack should you use to vibe code Axiom?
- Next.js with Tailwind CSS, TanStack Table, and Monaco Editor for query editing; Next.js API Routes and Node.js custom MCP server runtime; ClickHouse Cloud for high-performance event analytics storage; plus OpenTelemetry JS SDK for log/trace ingestion simulation, Zod for schema validation.