sc.Somnath Chattaraj

SOFTWARE ENGINEER · KOLKATA, INDIA

Thoughtful interfaces.
Dependable systems.

I’m Somnath. I build software with care — from the details of an Android interaction to the systems working behind it.

Information Technology · Jadavpur UniversityBuilding across product & infrastructure

01 SELECTED SYSTEMS

The engineering behind the interface.

Six projects, explored from source: the data models, execution paths, and trade-offs that shape them.

Real-time multiplayer01 / 06
Chess Club playing interface with chessboard, clocks, and scoresheet
Chess Club · repository preview
3+2 · 5+0 · 10+0public matchmaking time controls

PROJECT 01

Chess

Live chess with server-owned moves and clocks

Real-time multiplayer. A browser chess platform for online matchmaking, private invite games, and local pass & play, with a React board and server-validated rules.

An authenticated WebSocket connects players to a Node.js game server. PostgreSQL persists accounts, sessions, and game snapshots; reconnecting players recover the current position and running clocks.

  • React
  • TypeScript
  • Node.js
  • WebSocket
  • PostgreSQL
  • chess.js
  • Docker
Architecture & trade-offs
  • HTTP-only cookie sessions authenticate HTTP and WebSocket access. Matchmaking pairs time controls; private rooms use shareable invite codes. The server validates moves, clocks, and terminal results with chess.js.
  • Accepted moves and snapshots are stored before broadcasting. Active clocks are checkpointed each second; restart recovery charges elapsed downtime. Players can review game history and export PGN.

Design boundary. Live connections, matchmaking, and game coordination are process-local, so deployment requires one API replica. Horizontal scaling needs shared coordination and game ownership; an abrupt crash may lose the last clock checkpoint.

Developer tooling02 / 06
Echo landing page with Listen to every Echo of your users headline
Echo · supplied project image
20 items / pageHTTP query pagination

PROJECT 02

Echo

Embeddable feedback collection

Developer tooling. A project-keyed JavaScript widget captures feedback categories and page URLs, with an authenticated dashboard for triage, labels, and sentiment analysis.

A Next.js route emits an embeddable script that injects a feedback UI with prefixed styles and IDs. The widget posts to a CORS-enabled endpoint; Prisma persists typed feedback in PostgreSQL and TanStack Query retrieves paginated results.

  • Next.js
  • TypeScript
  • Prisma / PostgreSQL
  • Better Auth
  • TanStack Query
  • Gemini
Architecture & trade-offs
  • Project UUID keys identify public widget submissions. The script captures content, category, and window.location.href. Dashboard reads verify the session and project owner before returning newest-first feedback with labels.
  • A server action sends feedback text to Gemini 2.5 Flash and persists POSITIVE, NEUTRAL, or NEGATIVE sentiment. Filters and page numbers form the client query-cache key.

Design boundary. The dashboard is request-driven, not a WebSocket or SSE stream. Sentiment analysis is user-triggered; no automatic real-time analytics pipeline was found in the inspected source.

Observability & remediation03 / 06
Locally built AI_SRE OpSmith dashboard showing its empty overview, service panels, and activity area
Local build · API disconnected · no seeded telemetry
15s / 10 workersconfigured scheduler / queue concurrency

PROJECT 03

AI_SRE

Incident detection, retrieval & patch orchestration

Observability & remediation. A rule-gated anomaly pipeline connects Prometheus probes to a BullMQ worker pool, then retrieves source context for LLM-generated patches and GitHub pull requests.

A 15-second scheduler fans out checks to ten concurrent workers. Downtime, HTTP 5xx, or sustained latency spikes gate AI analysis; confidence below 0.7 and a five-minute incident cooldown suppress escalation.

  • TypeScript / Bun
  • BullMQ / Redis
  • Prometheus
  • Prisma / MongoDB
  • Chroma
  • MiniLM
  • Cerebras
Architecture & trade-offs
  • Latency detection requires both latest samples above 3σ and two seconds. BullMQ jobs have three attempts with exponential backoff. Source is split into 1,500-character chunks with 200-character overlap, embedded with MiniLM, and upserted into Chroma.
  • The patcher deduplicates multi-query retrieval, generates search/replace patches, validates paths, creates patch/<incidentId>, commits, records a health check, and attempts a GitHub PR through the REST API.

Design boundary. The inspected patcher does not execute patches in an isolated sandbox or run a build/test suite. Its health check does not gate PR creation. The screenshot is a real local UI capture, not evidence of an active production incident.

Distributed workflow orchestration04 / 06
AutoFlow landing page with Automate as fast as you can type headline
AutoFlow · supplied project image

AutoFlow — demo walkthrough

Prefer a separate tab? Watch on YouTube ↗

zap-eventsPostgreSQL outbox → Kafka → worker

PROJECT 04

AutoFlow

Webhook-to-worker automation engine

Distributed workflow orchestration. A four-service workflow system built around a PostgreSQL outbox and Kafka’s zap-events topic, with ordered email and Solana transfer actions.

The hooks service writes ZapRun and ZapRunOutbox together. A processor polls ten outbox rows every three seconds; workers consume stage-indexed events, interpolate payload fields, and publish the next stage.

  • TypeScript
  • KafkaJS
  • Express
  • Prisma / PostgreSQL
  • Solana web3.js
  • SMTP
Architecture & trade-offs
  • User → Zap → Trigger / ordered Actions describes definitions. ZapRun retains input metadata; ZapRunOutbox bridges committed runs into the event bus. Each service keeps a local Prisma schema.
  • The worker disables auto-commit, executes the matching sortingOrder stage, and commits offset + 1. Actions include SMTP email and a signed SOL transfer on Solana testnet through JSON-RPC.

Design boundary. The processor does not await Kafka publication before deleting outbox rows; the worker commits failed action offsets. This is a prototype delivery model, without an exactly-once guarantee or automatic action retries.

On-chain infrastructure05 / 06
Actual EcoX authentication screen with email login and carbon-credit artwork
Live authentication interface
ERC-721 × IPFSreceipt-first issuance pipeline

PROJECT 05

ECOx

Carbon offset & environmental verification engine

On-chain infrastructure. An authorized ERC-721 minting pipeline that turns certificate-derived quantities into tradable carbon-credit tokens on Avalanche.

Gemini extracts company and emissions data; Pinata stores IPFS metadata. Ethers waits for a mint receipt before refreshing a Prisma/PostgreSQL mirror. Chainlink Automation settles eligible marketplace auctions.

  • Solidity
  • Avalanche
  • Ethers
  • IPFS / Pinata
  • React
  • Express
  • Prisma / PostgreSQL
Architecture & trade-offs
  • An owner/minter allowlist guards minting. Tokens store quantity, expiry, retirement state, and a certificate URI; retirement burns the NFT and records reward points.
  • The verification endpoint uploads the certificate, extracts fields, pins metadata, mints, waits for a receipt, then calls an off-chain upsert by token ID.

Design boundary. Chain and database writes are separate; the refresh is not awaited by the response path. Reconciliation and validation of LLM-extracted quantities remain important consistency boundaries.

Community platform06 / 06
Locally built Campus Chatter public landing page
Campus Chatter · locally built landing page
100 requests / 60sconfigured per-user Redis rate limit

PROJECT 06

Campus Chatter

Identity-aware campus discussions

Community platform. A discussion platform combining reCAPTCHA-backed registration, academic-domain classification, cookie-based JWT authentication, and college/course relationships.

Express routes read relational posts, comments, and likes through Prisma/PostgreSQL. Redis caches feed/search results; Fuse.js performs in-memory fuzzy search over plain-text post content.

  • React
  • Express
  • Prisma / PostgreSQL
  • Redis
  • JWT
  • reCAPTCHA
  • Fuse.js
Architecture & trade-offs
  • Registration verifies reCAPTCHA and classifies institutional domains using a local allowlist with an academic-email fallback. Academic accounts attach college/course records; email links verify mailbox ownership.
  • Authenticated discussion endpoints apply a Redis counter with a 60-second expiry. Search results are cached for 300 seconds after HTML-to-text conversion and Fuse.js ranking.

Design boundary. Non-academic emails can register too; institutional classification is not a universal access gate. Search scans retrieved posts in memory, favoring simplicity over database-scale full-text indexing.

02 EXPERIENCE

Small details. Real impact.

Google

Bengaluru, Karnataka

May — Aug 2026

SOFTWARE ENGINEERING INTERN

A smoother way to switch tasks.

Worked on Android Recents production systems with mentors, subject matter experts, and two cross-functional teams spanning framework and UI rendering.

  • Implemented three task-switching interactions, including highlighted-task zoom and dynamic task-card scaling.
  • Optimized rendering and animations, reducing dropped frames by 4% during task switching.
  • Created 20+ test scenarios, debugged defects, documented design decisions, and incorporated 100+ code reviews before production rollout.
4%fewer dropped frames
20+test scenarios
100+code reviews incorporated

03 TOOLKIT & PERSPECTIVE

Curiosity, backed by craft.

My work spans frontend interactions, backend architecture, and the practices that keep software dependable.

01

Languages

Java, JavaScript, TypeScript, C++, Python, Kotlin, C, SQL

02

Application & data

Node.js, Express.js, React.js, MERN, REST APIs, Kafka, Redis, BullMQ, PostgreSQL, Prisma

03

Cloud & reliability

Docker, Kubernetes, Google Cloud Platform, Prometheus, monitoring

04

Engineering practice

Git, code review, production testing, debugging, performance optimization, technical documentation

05

AI tooling

LLMs, retrieval-augmented generation (RAG), ChromaDB, LangChain, AI-assisted development, output validation

04 FOUNDATIONS

Learning. Building. Iterating.

EDUCATION

Jadavpur University

B.E. in Information Technology

Kolkata, West Bengal
Aug 2023 — Expected Jun 2027

Relevant coursework

Computer Science Fundamentals, Data Structures & Algorithms, Distributed Systems, Operating Systems, DBMS

BEYOND THE CLASSROOM

  • 01

    Codeforces Specialist

    700+ algorithmic problems solved on LeetCode.

  • 02

    16th nationally · 143rd globally

    IMC Trading Prosperity 4.

  • 03

    Top 8 of 400+ teams

    East India Blockchain Summit Hackathon, IIT Kharagpur.