ADpulse - a Forgotten Idea ><

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

AdPulse is a real-time e-commerce intelligence platform built for Amazon and Shopify
sellers. The core idea is simple — connect your store and the platform automatically
monitors what your competitors are charging, tracks inventory signals, and fires
intelligent alerts the moment something changes. Price dropped below your threshold?
Alert fires. You get a live dashboard showing your prices versus competitors over
time with a drag and drop rule builder to define exactly what you want to be notified
about.

This is not a tutorial project. It mirrors the core product of funded startups like
Atom11, Perpetua, and Sellics — companies that have raised millions of dollars building
exactly this. I am building a production-grade version of their core product as my
final year project.

The tech stack is Node.js 20 + TypeScript 5 on the backend, PostgreSQL 16 with
pgvector, Redis 7, Prisma ORM, Docker + Docker Compose, Nginx, JWT auth, bcrypt,
Winston structured logging, and Next.js 14 on the frontend. Every architectural
decision was made the way a real engineering team would make it — not the way a
tutorial would.

GitHub: https://github.com/VaibhavXBhardwaj/adpulse

Demo

The project is currently in active development — Day 9 of a 90 day build plan.
The backend is fully functional and running in Docker. Here is what the API
looks like right now:

Health check — both services confirmed connected:

{
  "status": "ok",
  "services": {
    "database": "connected",
    "redis": "connected"
  },
  "environment": "development"
}

Product created and tracked:

{
  "status": "success",
  "data": {
    "id": "cmovax4zl000113o6wcv7579m",
    "asin": "B08N5WRWNW",
    "title": "Apple AirPods Pro",
    "brand": "Apple",
    "category": "Electronics"
  }
}

360 price points seeded across 30 days — own price vs two competitors:

{
  "id": "cmovb8k6m0003j29h2gz412fs",
  "price": 258.06,
  "source": "own",
  "currency": "USD",
  "recordedAt": "2026-04-07T15:55:12.810Z"
}

Frontend dashboard, charts, and alert rule builder are coming in Days 29-56.
Live deployment on AWS EC2 is planned for Days 57-70.

The Comeback Story

This project started as a blank folder. No boilerplate, no starter template,
no YouTube tutorial to follow. Just a PDF blueprint and a code editor.

The first few days were rough. Docker port conflicts with three other projects
running on my machine. Prisma 7 breaking changes that silently removed datasource
URL support from schema files — had to debug that from a cryptic error message
and downgrade to Prisma 5. The Prisma binary target mismatch between Windows and
Alpine Linux inside Docker — the container was generating for Windows but needed
linux-musl. Each one of these took real debugging to understand and fix properly.

By Day 9 here is what is fully built and working:

• Monorepo with Node.js 20 + TypeScript 5 backend and Next.js 14 frontend
• Full Docker Compose stack — PostgreSQL 16 with pgvector, Redis 7, Nginx, backend — all containerized and communicating correctly
• Complete Prisma schema with seven models — User, Tenant, Product, PricePoint, Alert, Notification, ApiKey — with proper relations, indexes, and cascade deletes
• Environment variable validation that refuses to start with missing config
• Winston structured JSON logging with per-request HTTP logging middleware
• Global error handler that catches everything and returns consistent responses
• Full JWT authentication built from scratch — register creates a Tenant and User in a single atomic Prisma transaction, bcrypt at cost factor 12, 7 day tokens
• RBAC middleware with ADMIN, ANALYST, VIEWER role hierarchy
• API key system — raw key shown once, SHA256 hash stored, same pattern Stripe uses
• Redis rate limiting per API key with sliding window and response headers
• Tenant isolation middleware — every database query is automatically scoped to tenantId at the middleware level, not the application level
• Full products service — create, list with search and pagination, get by ID, price history, competitor prices, delete
• PricePoint service with time series aggregation using PostgreSQL DATE() and DISTINCT ON for efficient latest-per-source queries
• Mock price generator that creates 360 realistic price points across 30 days for three sources — own, competitor_a, competitor_b

The comeback is that every single one of those pieces was built correctly the
first time in terms of architecture. No shortcuts. No copy-pasted code I cannot
explain. Every design decision was made the way a real engineering team would
make it.

The project is not finished. That is the point. It is 90 days of consistent,
committed, production-grade work. Every day gets a commit. The GitHub contribution
graph will be green every single day until this ships.

My Experience with GitHub Copilot

I have not used GitHub Copilot for the backend work built so far. Every line of
the authentication system, RBAC middleware, tenant isolation, and pricing service
was written manually — deliberately, because I needed to be able to explain every
line of it in a technical interview.

Starting from Day 29 when the frontend phase begins, I plan to use GitHub Copilot
specifically for the Next.js dashboard UI work. My intended workflow is to write
the component structure and business logic myself, then use Copilot to accelerate
the repetitive parts — generating Tailwind class combinations for layout, scaffolding
similar components once the pattern is established, and autocompleting recharts
configuration once I have set up the first chart correctly.

The goal is to use it as an acceleration tool for work where the pattern is already
clear in my head, not as a replacement for thinking through the architecture. The
backend was the architecture-heavy phase. The frontend is where speed matters more
and Copilot fits naturally into that workflow.

I will update this post when the frontend is complete with specific examples of
where Copilot helped and where I still had to write things manually.