Jitsu

Event data pipeline, honestly reviewed. Self-hosted, MIT-licensed, no per-event bill.

TL;DR

• What it is: Open-source (MIT) event collection and routing pipeline — the self-hosted alternative to Segment. Captures events from your website and apps and delivers them directly into your own data warehouse [1][2].
• Who it’s for: Founders and small engineering teams hitting Segment’s per-MTU pricing wall and wanting to own their pipeline instead of renting it. Also relevant for anyone who wants raw event data in a SQL-queryable warehouse they control [2].
• Cost savings: Segment’s Team plan starts at $120/month and scales with users. Jitsu self-hosted runs on a $10–20/month VPS with no per-event or per-user charges. At 50K MAUs, that delta compounds to $4,000–7,000/year [2][3].
• Key strength: Genuinely low barrier to add — one script tag, data flows into your warehouse within minutes. JavaScript Functions let you transform events server-side without leaving the platform [1][2].
• Key weakness: 4,680 GitHub stars is solid but modest compared to RudderStack’s community. The product went through a major v2 rewrite (“Jitsu Next”) that left a “classic” branch behind — outdated tutorials are a real hazard [1].

---

What is Jitsu

Jitsu is an event collection and routing layer. Drop a JavaScript snippet on your website — or use the React SDK, NPM package, or HTTP API — and it captures every user interaction: page views, clicks, signups, purchases, custom events. Those events route into a destination you own: ClickHouse, Snowflake, BigQuery, Redshift, Postgres, or MySQL [1][2].

The README description is direct: “Jitsu is an open-source Segment alternative. Fully-scriptable data ingestion engine for modern data teams. Set-up a real-time data pipeline in minutes, not days.” [1] That’s accurate. The website doubles down: “Implementation = add a Tag. That’s it. That’s the entire setup.” [2] Same zero-config magic that made Google Analytics ubiquitous — except the data lands on your server, not theirs.

What separates Jitsu from a plain tracking script is the transformation layer. Jitsu Functions are JavaScript functions that run on every event before it hits your warehouse. You can filter out bot traffic, enrich events with server-side context, trigger a Slack webhook on the first signup from a new domain, or deduplicate events across retries. The runtime has access to npm packages, a built-in key-value store for stateful logic, and a clean injected API (log, props, store, fetch) [1][2].

The project is MIT-licensed and YC-backed. Customers include Investing.com, Rarible, and Census [2]. The GitHub repo has undergone a significant v2 rewrite — “Jitsu Classic” (the original Go-based version) lives on master, while the current actively-developed version lives on the newjitsu branch and is the one the docs and website now describe [1].

---

Why people choose it over Segment, RudderStack, and Mixpanel

Jitsu’s primary competition is Segment — the incumbent event routing service that charges based on Monthly Tracked Users. The Segment pricing model is what drives founders toward alternatives: start free, traffic grows, bill grows, until you’re paying $400+/month for what is, mechanically, a data pipe.

The Jitsu value proposition is the same economics argument that drives most self-hosted tool adoption. When you hit $200–$500/month on Segment, a $15/month VPS running Jitsu replaces that bill permanently, and every byte of event data stays on infrastructure you control — it never touches a third-party server [1][2]. The HN launch thread drew exactly this crowd when the project surfaced [5].

The warehouse-first positioning is the architectural angle that resonates with teams who have lived through vendor lock-in: your event data lands directly in Snowflake or ClickHouse, not in Segment’s proprietary event store from which you export CSVs [2]. That architecture gives your BI tool, your data scientist, and your warehouse-native transforms direct SQL access from day one.

Versus Segment: Segment’s real advantages are its destination catalog (hundreds of pre-built SaaS integrations) and its CDP layer — audiences, computed traits, journey orchestration. Jitsu covers warehouses and core routing well. If your architecture is “collect events → write to warehouse → query from a BI tool,” Jitsu covers that entirely. If you need Segment’s audience segmentation features, Jitsu doesn’t have an equivalent.

Versus RudderStack: RudderStack is the other major open-source Segment alternative and runs a closer race. It has a broader integration catalog and more mature enterprise governance. Jitsu positions itself as simpler and faster to start — the single-tag story is genuine — while RudderStack has a heavier deployment footprint. For a two-person team, Jitsu is likely faster. For an enterprise with complex multi-destination routing, RudderStack may be more capable.

Versus Mixpanel/Amplitude: Different category. These are product analytics tools with their own proprietary event stores. They own your data and charge per MTU or per event. The right framing: Jitsu is the pipeline layer; Mixpanel is the analysis layer. Some teams run both — Jitsu to capture and warehouse raw events, then Metabase or Superset over ClickHouse for analysis.

---

Features

Event collection:

• HTML script tag, React/Next.js SDK, isomorphic NPM package (runs server-side in Node.js too), HTTP API, Segment API proxy [1]
• Sub-second delivery to warehouse [2]
• No-data-loss guarantee via Kafka buffering during warehouse downtime or maintenance [2]
• Automatic deduplication — send the same event multiple times, it’s stored once [2]
• Automatic schema management — Jitsu creates tables and columns as new event shapes arrive [2]
• Real-time identity stitching — links anonymous and identified users without custom SQL matching [2]

Jitsu Functions:

• JavaScript/TypeScript functions executed on every event before warehouse storage [1][2]
• Full npm package access inside functions [1]
• Built-in key-value store for stateful logic — classic example: fire a Slack webhook only on a user’s first signup [1]
• log, props, store, fetch injected by the runtime [1]
• Conditional routing, filtering, enrichment, and external webhook triggers all handled here [1][2]

Destinations:

• Warehouses: ClickHouse (free, included), Snowflake, BigQuery, Redshift, Postgres, MySQL [1][2]
• Additional connectors via destination catalog [2]
• Segment API compatibility — swap Jitsu in without touching upstream SDK code [1][2]

Infrastructure:

• Docker Compose quick start [1]
• Separate production deployment guide [1]
• Custom domain support — run the tracking pixel from your own subdomain to minimize ad-blocker impact [2]
• Jitsu is built on Bulker, a standalone open-source warehouse ingestion engine usable independently [1]

---

Pricing: SaaS vs self-hosted math

Jitsu Cloud:

• Free tier: up to 200,000 events/month, includes a free ClickHouse instance [1][2]
• Paid tiers: detailed pricing page not captured in available source data [3]

Self-hosted:

• License: $0 (MIT) [1]
• Infrastructure: $10–20/month VPS for moderate event volume; scale vertically as needed

Segment for comparison:

• Developer: free, 1,000 MTUs/month, 2 sources
• Team: $120/month for 10,000 MTUs
• Business: $1,000+/month, custom pricing above that

Concrete math at a real scale:

50,000 monthly active users, 10 events each = 500K events/month, 50K MTUs. On Segment Team ($120/month for 10K MTUs), you’ve exceeded the tier cap and are in custom pricing territory — typically $400–$600/month. On Jitsu self-hosted: $15/month VPS. The delta is $385–$585/month, or roughly $4,600–$7,000/year for a component that is, at its core, a data pipe.

The 200K-event free cloud tier is generous enough to run a real early-stage product — not a crippled trial tier [1][2].

---

Deployment reality check

The quick start is genuinely fast:

git clone --depth 1 https://github.com/jitsucom/jitsu
cd jitsu/docker
touch .env.local
# start per README

That gets you a working local Jitsu instance [1]. For production, the docs have a dedicated production deployment guide separate from the quick start — not just “run the same docker-compose in prod” [1][4].

What you actually need:

• Linux VPS with 2–4GB RAM
• Docker and docker-compose installed
• A domain and reverse proxy (Caddy or nginx) for HTTPS
• A warehouse destination, or use the included ClickHouse

What can go sideways:

The v1 → v2 rewrite is the main gotcha. “Jitsu Classic” and “Jitsu Next” have different architectures. The master branch on GitHub is Classic; the active newjitsu branch is the current version [1]. Blog posts and tutorials from before 2023 may describe Classic’s setup and concepts — follow those and you’ll be confused. Verify any third-party guide against the newjitsu branch documentation before trusting it.

ClickHouse is the right warehouse for event data at volume (column-oriented, fast aggregations). Postgres works fine for getting started; it degrades meaningfully at tens of millions of rows. Plan accordingly.

Functions debugging is less ergonomic than local Node.js development. The V8 isolate environment is powerful but error messages can be sparse. Budget time to get comfortable with the logging primitives before deploying complex transformation logic.

Realistic time for a technical user: 1–2 hours to a working production instance. For a non-technical founder with someone who can use a terminal: half a day, including warehouse connection and first verified events.

---

Pros and cons

Pros

• Full MIT license. Not “open core,” not “fair-code.” The entire platform is MIT — self-host, fork, embed in your product, resell to clients without a legal review [1].
• Near-zero SDK friction. One script tag and events start flowing. Same barrier-to-entry story as Google Analytics [2].
• Warehouse-first data model. Events land directly in SQL-queryable infrastructure you own. No proprietary store, no vendor export, no migration risk [2].
• JavaScript Functions are a real differentiator. Server-side event transformation with npm access and stateful KV storage — Segment charges enterprise prices for equivalent functionality [1][2].
• ClickHouse included free on cloud. Segment charges separately for storage; Jitsu’s cloud tier includes a ClickHouse instance at no extra cost [1][2].
• Segment API compatibility. Swap Jitsu in as a drop-in replacement without changing frontend instrumentation [1][2].
• Real-time identity stitching built in. Not a paid add-on — anonymous-to-identified user linking is standard [2].
• Custom domain support. Route the tracking pixel through your own subdomain to preserve data accuracy against ad-blockers [2].

Cons

• 4,680 GitHub stars is modest for the category. RudderStack and PostHog have significantly larger communities. Fewer community-written connectors, fewer answered questions in forums [merged profile].
• The v1/v2 rewrite created documentation fragmentation. Classic vs. Next is confusing, the README still links to a blog post explaining the difference, and some docs sections appear to lag the current codebase [1].
• Destination catalog is narrower than Segment’s. If you need direct routing to 40 different SaaS tools without custom code, Segment wins on breadth. Jitsu covers warehouses and standard connectors; long-tail destinations require Functions [2].
• No visualization layer. Jitsu is strictly a pipeline — no funnels, no dashboards, no session recording. You need a separate BI tool on top of the warehouse to see your data [2].
• Production deployment is non-trivial for non-technical users. The docker-compose quick start is easy; a production deployment with proper persistence, backups, and failover requires genuine infrastructure experience [1][4].
• Independent public reviews are sparse. Unlike automation or CMS tools with dozens of third-party evaluations, Jitsu’s community signal lives primarily in HN threads and GitHub issues rather than independent in-depth reviews [5].

---

Who should use this / who shouldn’t

Use Jitsu if:

• You’re paying Segment $120+/month and your usage is stable enough to handle a one-time migration.
• You want event data landing directly in a warehouse you own — Snowflake, BigQuery, Postgres, or ClickHouse — without any proprietary intermediary.
• You have a developer who can deploy Docker Compose and configure a reverse proxy, or you’ll pay someone to do it once.
• You’re already on Segment’s SDK and want a zero-instrumentation-change migration path [1][2].
• You need server-side event transformation without paying Segment’s enterprise tier for it.

Skip it (stay on Segment) if:

• Your team depends on Segment’s 400+ SaaS destination integrations and has no bandwidth to replace them with custom Functions.
• No one on your team can manage a self-hosted service, and the Segment bill is still less than an engineer’s attention.
• You need Segment’s CDP features: computed audiences, computed traits, journey orchestration — Jitsu has no equivalent.

Skip it (pick PostHog) if:

• You want product analytics and event collection in one tool with a UI your PM can use directly, self-hosted.

Skip it (pick RudderStack) if:

• You’re at a larger organization with complex multi-destination routing needs and want enterprise support contracts behind the open-source core.

---

Alternatives worth considering

• Segment — the incumbent Jitsu is specifically designed to replace. Easiest onboarding, widest destination catalog, most expensive at scale, fully closed source.
• RudderStack — the other serious open-source Segment alternative. Broader integrations, heavier deployment, more enterprise-targeted.
• PostHog — open-source product analytics with event capture included. Different angle: gives you funnels, session recording, and feature flags on top of the event data. Right if you want the analysis layer self-hosted, not just the pipeline.
• Snowplow — open-source, extremely configurable, designed for large-scale data engineering teams. Significantly more complex to operate than Jitsu.
• Plausible / Fathom — privacy-first site analytics. Much simpler and lighter. Right if you just want traffic stats without a full data warehouse pipeline.
• Mixpanel / Amplitude — SaaS product analytics. Different category: they own your data and charge per MTU. If you want to own your data, these are the incumbents Jitsu helps you exit.

---

Bottom line

Jitsu is a clean answer to a specific and common problem: your Segment bill is growing with your user count, and the marginal cost of the data pipe is harder to justify every quarter. The MIT license is genuine, the warehouse-first architecture is the right model for teams that want real data ownership, and the JavaScript Functions layer delivers server-side transformation that Segment gates behind enterprise pricing. The trade-offs are also real: a smaller community than the category leaders, documentation fragmentation from a mid-history rewrite, and a destination catalog that covers warehouses well but requires custom code for long-tail SaaS routing. For the target use case — a founder running a product with 20,000–100,000 MAUs who is tired of Segment’s MTU pricing — the self-hosted math is decisive. A $15/month VPS and one deployment afternoon replace a $400+/month recurring bill you’ll otherwise pay indefinitely.

If the deployment is the blocker, that’s a one-time job — exactly what upready.dev handles for clients.

---

Sources

1. Jitsu GitHub Repository and README — github.com. https://github.com/jitsucom/jitsu
2. Jitsu Official Website — jitsu.com. https://jitsu.com
3. Jitsu Pricing Page — jitsu.com. https://jitsu.com/pricing
4. Jitsu Documentation — Self-Hosting — docs.jitsu.com. https://docs.jitsu.com/self-hosting
5. Jitsu Launch on Hacker News — news.ycombinator.com. https://news.ycombinator.com/item?id=29106082