All projects
Syncro logo
Founder · Solana Indexing SaaS

Syncro

An indexing platform for Solana.

A high-performance Solana indexing platform: write a transform in the browser, and stream structured on-chain data straight into your own Postgres — no proprietary schema, no lock-in.

Year
2026
Role
Founder & Engineer — control plane, data plane, infra & product
RustAxumWebAssemblywasmtimeAssemblyScriptPostgreSQLRedisRabbitMQKubernetesNext.jsPaddle

Overview

Syncro is the SaaS I'm building now — the bridge between Solana's raw RPC/gRPC firehose and the Web2 relational database a product team already runs. Developers write a small AssemblyScript transform in a browser Monaco editor; the platform compiles it to sandboxed WebAssembly, spins up a dedicated Rust worker on Kubernetes, and that worker executes the Wasm per transaction and streams structured rows directly into the user's own Postgres — with schema migrations, backpressure and credit metering all handled for them.

Wasm

sandboxed user transforms

BYODB

streams into your own Postgres

Rust

API, workers & wasmtime runtime

K8s

a dedicated pod per indexer

The problem

Solana emits more data than any other chain — a relentless firehose of transactions over RPC and gRPC. But that raw stream is useless to a product team: there's no easy way to land it, in a shape they control, inside the database their app already speaks to. Today teams have two bad options. They rent rigid, opinionated indexers that trap their data behind a proprietary schema and API, or they hand-roll fragile Rust pipelines — babysitting RPC backpressure, reinventing batching, migrations, sandboxing and billing every time. Syncro deletes that entire middle layer: you describe the shape you want, point it at your own database, and the data shows up.

What I built

  • A browser-based Monaco editor where developers write a simple AssemblyScript transform mapping on-chain accounts to their own schema — compiled server-side to a sandboxed Wasm binary and cached in Redis for instant pod boots.
  • Generic Rust indexer workers (wasmtime) that boot from an INDEXER_ID, load the user's Wasm, serialize each Solana transaction via Borsh into linear memory, and stream the structured output straight into the user's own Postgres (Bring Your Own Database).
  • A visual schema builder that generates versioned SQL migrations and applies them safely on pod boot via an _indexer_migrations_history table — additive-only, so a schema change can never silently wipe a user's data.
  • A Spinner microservice that drives the Kubernetes API over RabbitMQ to spawn, pause and kill a dedicated worker pod per indexer, with Redis distributed locks preventing duplicate deploys on a double-clicked button.
  • Backpressure-aware batching: workers batch rows in memory and throttle the Solana read-stream the moment the user's DB slows down — preventing OOM — with bb8/deadpool pooling shielding user databases from connection storms.
  • A prepaid credit system with a Redis atomic DECR per transaction (no Postgres lock on the hot path) and Paddle-powered auto-recharge — Merchant-of-Record billing that bakes in global tax compliance for an India-based entity.

Architecture

VPC Fortress

The front-end lives on Vercel's edge; the control and data planes are locked inside a single private VPC on managed Kubernetes (EKS/GKE). Only the Rust API is publicly reachable, over HTTPS — Redis, RabbitMQ, the platform DB and every worker pod have zero public ingress.

Two node groups

A lightweight, highly-available control-plane group runs the microservices, Redis and RabbitMQ. A separate compute-optimized, auto-scaling data-plane group runs nothing but isolated Rust indexer pods, so noisy workers can never starve the API.

Wasm + tenant isolation

User code never runs as native. Each transform executes inside a wasmtime sandbox with strict Kubernetes CPU/RAM limits per tenant, so one user's logic can't read another's data or take down a node.

SSRF guardrails

Because users bring their own database URL, the API validates every connection string — blocking localhost and private ranges (10.x, 192.168.x, etc.) — before a worker is ever allowed to dial out.

Where it stands

In active development as my current flagship — a founder-led, full-stack build spanning a Rust control plane, a WebAssembly data plane, Kubernetes orchestration and a Next.js product surface. The hard, defining parts — Wasm execution, BYODB migrations, backpressure and high-speed credit metering — are exactly what I'm building right now.

More work