Here's the article-style body for EventPulse Analytics, matching the format from before.

EventPulse Analytics — your own Mixpanel, self-hosted

Every analytics platform eventually asks you the same question: whose servers do you want your user data sitting on? Segment, Mixpanel, and Amplitude are excellent tools, but they mean your event data leaves your infrastructure the moment it's tracked. EventPulse Analytics is what happens when you build the same category of tool but keep it entirely under your own roof.

What it is

EventPulse is a production-grade, multi-tenant event analytics platform — track events from any app, watch them flow into a real-time dashboard, and never send a single row of data to a third party. It's built to handle real load: batched ingestion through a Redis queue, background aggregation, and a WebSocket layer that pushes updates to the dashboard in under a second.

Core features

Ingestion and processing

High-throughput event ingestion — batches of up to 1,000 events per request
Redis-backed queue with APScheduler dequeuing and bulk-inserting every 5 seconds
Scheduled aggregation, cleanup, and alert evaluation running in the background
API key system (ep_live_*) — SHA-256 hashed, individually revocable

Real-time dashboard

Live WebSocket event stream via Redis Pub/Sub, with channel-based subscriptions
Metric cards, time-series charts, and top-events breakdown, all auto-refreshing
Live feed with pause/resume and CSV export
A paginated, filterable events browser with expandable row detail

[Image: live feed screenshot, events streaming in]

Alerts

Expression-based alert rules with configurable severity
Cooldown enforcement so a single spike doesn't spam you
Full trigger history and a dry-run test mode before rules go live

Auth and access

JWT authentication with access and refresh tokens
Atomic, sliding-window rate limiting via a Lua script in Redis
X-RateLimit-* headers on every response

Ship data from anywhere

One of the more deliberate design choices was making integration painless regardless of stack:

SDKInstallTargetsJS drop-in<script src="...">Any HTML page, no build stepeventpulse-analyticsnpm install eventpulse-analyticsReact, Vue 3, TypeScripteventpulse-pythonpip install eventpulse-pythonPlain Python, Django, FastAPI

A drop-in script auto-tracks page views and clicks with zero configuration. The React hook and Vue plugin wrap the same client in idiomatic patterns for each framework. The Python SDK ships with dedicated Django middleware and a FastAPI/Starlette middleware, so tracking backend events takes one line in settings.py or main.py.

Under the hood

LayerTechnologyBackendPython 3.11, FastAPI, async SQLAlchemy, APSchedulerDatabasePostgreSQL (Supabase)Cache / queueRedis (Upstash)FrontendReact 18, Vite, Tailwind CSS, RechartsMonitoringSentry, structured JSON loggingDeploymentRender (backend), Vercel (frontend)

[Image: architecture diagram — client apps → FastAPI → Postgres/Redis → WebSocket]

The event flow is straightforward by design:

An SDK sends a batch to POST /api/v1/ingest/events/batch
Events land in a Redis list
APScheduler dequeues and bulk-inserts into PostgreSQL every 5 seconds
Aggregates are recomputed and dashboard metrics refresh
New events publish to Redis Pub/Sub, and WebSocket clients receive them live

A few decisions worth calling out:

Atomic rate limiting via Lua — avoids race conditions that a naive read-then-write counter would hit under real concurrency.
Batch-first ingestion — a single request can carry up to 1,000 events, which is what makes 5,000+ events/sec throughput realistic on modest infrastructure.
No vendor lock-in, by construction — every layer (Postgres, Redis, the API itself) runs on infrastructure you choose and control.

Try it

The full stack is live — a hosted backend with interactive Swagger docs, a published npm package, and a published PyPI package, so you can wire up tracking in a test project in minutes.