DEV Community: Soumyadip Maity

I built a production analytics SaaS solo as a B.Tech student — here's what 4 months taught me

Soumyadip Maity — Sat, 27 Jun 2026 09:20:45 +0000

Why I built it
I wanted privacy-first analytics without Mixpanel's complexity or price. So I built my own.
What it does
UCoder Insights tracks real user behavior — sessions, errors, page events — with a clean dashboard and zero third-party data sharing.
Stack: MongoDB timeseries + Redis + Express + React + Next.js. Deployed on Azure with Cloudflare CDN.

Published npm package: ucoder-insight
What I learned from real users
5 projects are using it in production today. Their feedback directly shaped the product:
Wanted better error tracking UI → built it
Wanted session breakdowns → built it
Wanted richer graphs → built it
College doesn't teach you this. Real users do.
What's next
More integrations, better Core Web Vitals tracking, and hopefully more users.
If you're building something similar or want to try it out:
🔗 insights.ucoder.in
📦 npm install ucoder-insight

I Launched My Analytics Tool 3 Months Ago. It Got 1 Upvote. Here's What I Rebuilt.

Soumyadip Maity — Sun, 07 Jun 2026 04:16:39 +0000

The Original Problem (Still Valid)

Google Analytics sends every user interaction to Google's servers. Every click, every session, every IP address — all of it leaves your infrastructure.

For developers who care about user trust, that's a problem.

The alternatives were either expensive (Mixpanel at $28/month), limited (Plausible gives you pageviews but no custom events or error tracking), or painful to self-host (Matomo).

So I built my own. The idea was solid. The execution needed work.

What Was Wrong With v1

Problem 1: API response time was 3-4 seconds

Every analytics event was being written to MongoDB synchronously, inside the request handler. Under any real load, this meant:

The /log endpoint was slow
Events were being dropped
The tracked application felt the impact

This was unacceptable for an analytics tool. Analytics should be invisible.

Problem 2: Wrong database schema for time-series data

I was storing analytics events as regular MongoDB documents. That works, but it's not optimized for what analytics actually is: time-ordered data queried by date range.

Queries like "show me the last 7 days" were doing full collection scans.

Problem 3: No separation of concerns

User data, analytics events, settings, API keys — all mixed together in MongoDB. No relational integrity, no proper foreign keys, no ACID transactions where they were needed.

What I Rebuilt

Fix 1: MongoDB Time-Series Collections

MongoDB has a purpose-built collection type for time-ordered data. I migrated all analytics events to Time-Series collections.

The result:

Automatic data bucketing by time — range queries are now index-native
Columnar compression — storage costs dropped significantly
Built-in TTL — data automatically expires after 6 months, no manual cleanup
API response: 3-4 seconds → 400ms

That's not a typo. The same query that took 3-4 seconds now runs in under 400ms.

Fix 2: Async Processing With BullMQ + Redis

The /log endpoint no longer writes to MongoDB directly. Every incoming event goes into a BullMQ job queue backed by Redis. A background worker processes the queue and writes to MongoDB asynchronously.

Client SDK
   │
   ▼
Express API  ──→  BullMQ Queue (Redis)
                       │
                       ▼
                  Worker Process
                       │
                       ▼
             MongoDB Time-Series

The API endpoint now just validates the request and pushes to the queue — it responds in milliseconds. Events are processed in the background. Your application is never affected.

Fix 3: Polyglot Persistence

Analytics events belong in MongoDB Time-Series. But user accounts, project settings, API keys, and billing records are relational data — they have foreign key relationships and need ACID transactions.

I added PostgreSQL via Supabase for all relational data. Supabase also handles Row Level Security.

Now the data layer is:

Data Type	Database
Analytics events	MongoDB Time-Series
Users, projects, settings	PostgreSQL (Supabase)
Queue, caching, presence	Redis

Each database does what it's best at. This is called polyglot persistence — and it's the right pattern for this kind of workload.

Fix 4: Real Infrastructure

v1 was running on a basic setup. v2 runs on:

Microsoft Azure VPS — backend server
Cloudflare CDN — global edge delivery, DDoS protection
PM2 — process management, zero-downtime restarts
Nginx — reverse proxy

New Features in v2

Beyond performance, I added features that were missing:

Scroll depth tracking — how far users actually scroll (Pro)
Core Web Vitals — LCP, FID, CLS from real users (Pro)
Domain ownership verification — DNS TXT record or meta tag, so you can only track sites you own
On-demand data deletion — delete individual events, date ranges, or everything from the dashboard
Free forever plan — no credit card, no expiry

The Current Stack

Layer	Technology
SDK	TypeScript, Beacon API, ~7.4KB gzipped
Frontend Dashboard	Next.js, React, TypeScript, Tailwind CSS, Shadcn UI
Backend	Node.js, Express, TypeScript
Analytics DB	MongoDB Time-Series
Relational DB	PostgreSQL via Supabase
Queue	BullMQ + Redis
Auth	Supabase Auth (OTP)
Infrastructure	Microsoft Azure + Cloudflare
SDK Distribution	npm + jsDelivr CDN

What the Dashboard Looks Like Now

The dashboard gives you:

Page views, sessions, bounce rate
Custom events with properties
JavaScript errors with stack traces
Referrers, UTM params, device/browser breakdown
User location (country/city only — IP is discarded immediately after geolocation)
Scroll depth heatmap (Pro)
Core Web Vitals from real users (Pro)

All without a single cookie. No consent banner required.

The Privacy Architecture (Unchanged, Still Core)

This didn't change between v1 and v2 because it was right from the start:

No IP storage — IPs are used for geolocation then immediately discarded
No cookies — session identity uses a daily-rotated hash, no persistent tracking
No cross-site tracking — your data stays in your project
No data selling — ever
GDPR, CCPA compliant — no consent banner needed because no tracking cookies

What I Learned From 1 Upvote

The product wasn't the problem. The launch was.

I posted on Product Hunt with a brand new account, no audience, no prior community engagement. The algorithm doesn't surface products from cold accounts. That's not a conspiracy — it's just how it works.

The lesson: build an audience before you need it.

I'm doing that now. Writing here, sharing on Twitter, building in public. If you're reading this, you're part of that process.

Try It

npm install ucoder-insight

import { initUcoderInsight } from 'ucoder-insight';

initUcoderInsight("YOUR_PROJECT_ID");

That's the entire setup. It auto-tracks page views, SPA navigation, JavaScript errors, and Core Web Vitals from that single line.

🔗 Platform: insights.ucoder.in
📦 npm: npmjs.com/package/ucoder-insight
📖 Docs: insights.ucoder.in/docs

If you're building something and tired of sending your users' data to Google — give it a try.

And if you have feedback, I genuinely want to hear it. Drop a comment.

Built by Soumyadip Maity — Full Stack Developer, final year CS student, West Bengal, India.
Previously: I Was Tired of Sending My Users' Data to Google — So I Built My Own Analytics

I Was Tired of Sending My Users' Data to Google — So I Built My Own Analytics

Soumyadip Maity — Mon, 01 Jun 2026 11:26:23 +0000

I'm a final year CS student. I build things in production.

Last year, I was working on [Ucoder](https://www.ucoder.in) — a full-stack platform I've been building since college. At some point I needed analytics. I wanted to know: are people actually using this? Which features are being used? Where are errors happening?

So I did what everyone does. I installed Google Analytics.

It worked. But something felt wrong.

The Problem

GA4 sends every user interaction to Google's servers. Every click, every session, every user's IP and device — all of it leaves your infrastructure and goes somewhere you don't control.

For a platform where I cared about user trust, that felt like a betrayal.

So I looked at alternatives:

Plausible — privacy-first, cookie-free, clean dashboard. But it only gives you pageviews, referrers, and bounce rate. No custom events, no error tracking, no real product analytics.
Mixpanel — powerful, but $28/month per 10K users. At scale, brutal. And the setup takes half a day just for event taxonomy.
Microsoft Clarity — session replays and heatmaps only. No event tracking.
Self-hosted Matomo — closer, but heavy to maintain and the UI feels dated.

None of them did what I actually needed:

Track real user behavior, capture errors, support custom events — without cookies, without sending data to a third party, and without a painful setup.

So I built it myself.

Introducing Ucoder Insights

Ucoder Insights is a privacy-first, cookie-free analytics platform with its own npm SDK.

It tracks:

📄 Page views (SPA-aware, works with Next.js, React, Vue)
⚡ Custom events
🔴 JavaScript errors (with stack traces)
📊 Core Web Vitals (LCP, FID, CLS)
🌐 Referrers, UTM params, device/browser info

All without cookies. All processed on your own terms.

How It Works — Technical Overview

The SDK

npm install ucoder-insight

import { initUcoderInsight } from 'ucoder-insight';

initUcoderInsight("projectid"{
  // Your optional settings here
});

That's it. One function call. No configuration overhead.

The SDK is ~9.5KB gzipped. It uses a beacon API to send events so it never blocks the main thread. For SPAs, it listens to history.pushState and popstate to track client-side navigation automatically.

The Backend Architecture

The backend is built with Express 5 + TypeScript. When an event comes in:

Request hits the Express API
Passes through express-validator for input sanitisation
Gets pushed into a BullMQ job queue backed by Redis
A background worker processes the queue and writes to MongoDB

Why a queue? Because analytics should never slow down your app. If the ingestion endpoint is under load, events queue up and get processed asynchronously — your tracked application is never affected.

Client SDK
   │
   ▼
Express API  ──→  BullMQ Queue (Redis)
                       │
                       ▼
                  Worker Process
                       │
                       ▼
                   MongoDB

Privacy by Design

No cookies — identification uses a daily-rotated hash of IP + User-Agent. No persistent tracking across days.
No PII storage — we never store IPs or personal data.
Your data stays yours — events go to your project only, not a shared Google/Meta data warehouse.

What This Solves That Others Don't

1. Error Tracking + Analytics in One Place

With GA4 or Plausible, you need a separate tool (Sentry, LogRocket) for error tracking. With Ucoder Insights, JavaScript errors are captured automatically — with the page URL, user agent, and stack trace — right alongside your pageview and event data.

No context switching between dashboards.

2. Real Custom Events, Simply

import { trackEvent } from 'ucoder-insight';

// Track anything
trackEvent('signup_completed', { plan: 'free', method: 'email' });
trackEvent('feature_used', { feature: 'export_csv' });

Plausible's custom events require manual script tagging. Mixpanel requires you to plan an entire event taxonomy before you start. Here, you call one function.

3. SPA-First

Most analytics tools were built for traditional multi-page websites. Ucoder Insights was built with SPAs in mind from day one — it handles pushState navigation, React Router, Next.js App Router, and hash-based routing out of the box.

The Stack

Layer	Technology
SDK	TypeScript, Beacon API
Frontend Dashboard	Next.js 16, React 19, Tailwind CSS 4
Backend	Express 5, TypeScript, Socket.IO
Queue	BullMQ + Redis (ioredis)
Database	MongoDB (Mongoose 9)
Deployment	Docker + PM2 on Linux VPS

Current Status

The platform is live at insights.ucoder.in and running in production on Ucoder.in.

The npm package ucoder-insight is public at v1.1.3.

I'm a solo developer and this is a real project — not a side project I'll abandon. I use it myself, which means I have a real incentive to keep it working and improving.

What's Coming Next

Alert system — get notified on Slack/email when error rate spikes or traffic drops
Server-side proxy — bypass ad-blockers without compromising privacy
Funnel analysis — visualise conversion paths across custom events
API access — pull your analytics data into your own dashboards

Try It

npm install ucoder-insight

🔗 Platform: insights.ucoder.in
📦 npm: npmjs.com/package/ucoder-insight
💻 My portfolio: soumyadip.ucoder.in

If you're building something and tired of sending your users' data to Google — give it a try. And if you have feedback, I genuinely want to hear it.

Built by Soumyadip Maity — Full Stack Developer, final year CS student, West Bengal, India.