Divyansh Srivastav

Engineering teams merge code every day without knowing the full blast radius of what they're shipping — a leaked API key, a silent $15k/month AWS bill increase, or a repository-pattern violation that becomes a technical debt time bomb. OpsMind AI acts as an always-on automated senior reviewer that intercepts every pull request before it merges.

What makes it different:

• Three concurrent AI agents (not one) — security, cost, and architecture reasoned about independently via goroutines, full context each
• Self-improving via an MLOps feedback loop — engineer overrides are logged and inform future runs; architecture rules are defined in plain English, embedded via Gemini, matched via pgvector semantic search
• Interactive RAG chatbot — ask "what security issues exist in admin.go?" and get streamed, source-cited answers
• Runs entirely on free tiers — Go backend, PostgreSQL + pgvector on Neon, React dashboard on Render — $0/month, no expiring resources

Stack: Go (concurrent backend) · PostgreSQL + pgvector on Neon · Groq (GPT-OSS 120B) for agents/RAG · Gemini embedding-001 for vectors · React + TypeScript (Vite) · Docker · GitHub Actions CI · Render hosting

Status: Live in production, verified end-to-end on a real GitHub repository, with a 10-test Go test suite and a full CI pipeline on every push. The backend is on Render's free tier, so it may take 30–60s to wake up after inactivity.

Most "trading" portfolio projects stop at a gatekeeper — validate a request, check a balance, forward it along. This project implements an actual order-matching engine, the component that sits at the heart of every real exchange (NYSE, NASDAQ, NSE): incoming buy/sell orders are matched in real time, enforcing price-time priority and handling partial fills, with a live order book kept entirely in memory for sub-millisecond access.

What's unique:

• A real matching algorithm — TreeMap-based order book (ConcurrentSkipListMap) with O(log n) insertion, O(1) best-price lookup, FIFO queues per price level. Caught and fixed a genuine stale-price-level bug via testing, now covered by a permanent regression test
• Strategy-pattern adaptive rate limiting, tiered by client type, tightening automatically under detected volatility — no manual intervention
• A genuine circuit breaker — full state machine, verified to trip, reject fast, and self-test recovery
• Time-in-Force semantics (GTC/IOC/FOK), a min-heap expiry scheduler, and a full order lifecycle state machine

Stack: Java 21 + Spring Boot 4.1 · PostgreSQL 16 (Flyway migrations) · Redis 7.2 · Redpanda (Kafka-compatible) · Docker Compose — 100% free and runs entirely locally, no cloud cost

Load testing: 69 orders processed, 40 trades matched, 0 errors across concurrent test runs. Honest caveat: most of the ~91ms latency is synchronous DB writes and the Kafka publish call, not the in-memory matching itself — moving trade persistence fully onto the async Kafka consumer path is the natural next optimization.

A modern, real-time cryptocurrency tracking and portfolio management app built solo during my SDE internship at Ultimez Technologies.

Frontend: React 18 + TypeScript, Tailwind CSS, Recharts, React Router, Axios, Lucide React

Backend: Node.js + Express, MongoDB Atlas + Mongoose, JWT auth, bcryptjs for password security

API: CoinGecko API for live market data

Security design:

• Passwords hashed with bcrypt (unique salt auto-generated, deliberately slow to resist brute-force)
• Lockout status checked before password comparison — a locked account never leaks whether a subsequent attempt would have been correct
• TOTP secret only activates after the user confirms one valid code, preventing accidental lockout from a mistyped secret
• All queries parameterized (no SQL injection); username uniqueness enforced at the database level

Kept intentionally to three Go source files, each with a single clear responsibility. Dependencies are vendored so the Docker build never depends on network access to Go's module proxy — fully self-contained and reproducible. Uses a pure-Go SQLite driver (no CGO), and a multi-stage Docker build keeps the final runtime image small.

Stack: Go · SQLite (modernc.org/sqlite) · bcrypt · pquerna/otp (TOTP) · chzyer/readline (CLI) · Docker + Docker Compose