Surya
Prabhav
Gurram

Overview: A production-grade multi-agent system built on Claude, GraphQL subscriptions, pgvector, and TypeScript — simulating what Salesforce deploys for Fortune 500 enterprise sales teams.

Technical Explanation: Built a Router → CRM / Research / Synthesis agent pipeline where the Router classifies queries as JSON {targetAgent, reasoning, enrichedQuery} and runs parallel agents via Promise.all for complex queries. Real-time per-token streaming is delivered over GraphQL WebSocket subscriptions with 8 typed event types (ROUTING, TOOL_CALL, APPROVAL_REQUIRED, etc.). Implemented Human-in-the-Loop: the agent pauses on destructive CRM writes, emits an APPROVAL_REQUIRED event, and polls the DB every second for up to 5 minutes until the user approves or rejects via the UI. Vector memory uses pgvector cosine similarity (embedding <=>) on conversation history for contextual RAG. Added prompt versioning and LLM-as-judge eval runner that scores agent outputs with Claude — agent-specific eval cases prevent cross-domain noise. Deployed on Railway with separate backend (Apollo Server), frontend (React + nginx), and managed PostgreSQL services.

Overview: An Agentforce-style AI customer support agent built on Salesforce Service Cloud, Claude API, pgvector, and React. Intercepts incoming Cases via Apex Triggers, classifies them with Claude (sentiment, urgency, category, confidence), generates knowledge-base-grounded draft responses, and surfaces low-confidence cases for human review — fully automated in under 10 seconds.

Technical Explanation: Built CaseTrigger + CaseAIHandler (Queueable + Database.AllowsCallouts) to intercept Cases on AFTER INSERT and call a Node.js backend via Named Credential — 7 custom AI fields written back to the Case record automatically. Exposed a CaseResolutionAction @InvocableMethod for Agentforce flow integration, enabling the AI pipeline to be triggered natively from Agentforce agent actions and Flow Builder. Draft response pipeline retrieves category-matched knowledge base articles from PostgreSQL with pgvector, using keyword-weighted ranking with cosine similarity ready for real embedding upgrades. Human-in-the-Loop approval gates any case with confidence <70% — flagged as AI_Needs_Review__c = true and routed to Pending Review. LLM-as-judge eval runner scores draft quality across 5 dimensions (empathy, accuracy, tone, clarity, completeness) — 79.7% avg score across 32 evals, score range 66–91%. Deployed full stack to Railway. End-to-end: Salesforce Case Created → CaseTrigger → CaseAIHandler → /api/classify → /api/draft → AI fields written back in <10s.

Overview: A production-grade adaptive movie recommendation system trained on MovieLens-25M (162,541 users, 32,720 items) — implementing a full three-stage neural pipeline (BERT4Rec pretrain → Two-Tower retrieval → Cross-Attention ranking) with Claude LLM re-ranking and continual learning. Achieved Recall@10 = 0.51 and pairwise accuracy = 0.97.

Technical Explanation: Stage 1 pre-trains a BERT4Rec Transformer (d=256, 2 layers, 4 heads, 10M params) with masked item prediction and weight-tied output projection for self-supervised representation learning. Stage 2 trains a Two-Tower model (User: BERT4Rec backbone → mean pool → MLP; Item: id embedding + sentence-transformer text) with InfoNCE contrastive loss (temperature=0.07), serving a pre-computed item embedding index via pgvector HNSW for sub-millisecond ANN retrieval. Stage 3 uses a Cross-Attention Ranker where the item embedding queries the full user sequence via MultiheadAttention, then a 3-way feature interaction [user_pool, item_emb, user_pool×item_emb] → MLP → scalar, trained with IPS-weighted BPR loss to debias popularity. LLM re-ranking passes top-20 neural candidates + last 10 interaction titles to Claude, which returns a JSON re-ranked list with chain-of-thought reasoning. Cold-start routing switches users with <3 interactions to content-based retrieval (sentence-transformer cosine similarity). Evaluation uses LLM-as-judge: Claude scores recommendations on relevance, diversity, novelty, and serendipity. FastAPI backend with background eval + continual learning triggers; React frontend (4 views). Deployed API on Railway, frontend on Vercel.

Overview: A production-grade real-time feature store purpose-built to back UserLens — handling the full feature lifecycle from raw MovieLens interactions to sub-5ms online reads at inference time. Implements dual-pipeline architecture (Airflow batch + Kafka streaming), a partitioned Parquet offline store, Redis online store, FastAPI feature server, and a live React monitoring dashboard across 17 features for 610 users and 9,742 items, fully deployed on Railway.

Technical Explanation: The batch pipeline runs nightly via an Airflow DAG (SequentialExecutor, scheduled 02:00 UTC): extract_interactions stages ratings + movies as Parquet, then compute_user_features and compute_item_features run in parallel. User features include windowed interaction counts (7d/30d), avg rating with all-time fallback, and 5 genre affinities computed via vectorized str.split + explode + groupby — cutting computation from ~60s to under 1s on 100k rows. Item features include popularity windows (7d/30d), global rating stats, a cold-start flag (fewer than 5 interactions in 30d), and IPS debiasing weights (√(1/propensity), normalized to mean=1, clipped [0.01, 10]) for popularity bias correction in UserLens training. After computation, write_online_store pipelines all features to Redis hashes with typed TTLs (7d users, 2d items) in batches of 5,000. Partition metadata (row counts, timestamps, columns) is written to a feature_partition_metadata PostgreSQL table — surviving Railway's ephemeral filesystem across every redeploy.

The streaming pipeline uses a Kafka producer replaying MovieLens events at 50 events/sec and a Faust async consumer that maintains three Redis structures per event: user:{id}:session (LPUSH + LTRIM to last 10 items, 24h TTL) for BERT4Rec sequence input; user:{id}:last_ts (unix timestamp) for live recency score computation (exp(−λ·elapsed_days), λ=ln(2)/2, half-life 2 days); and item:{id}:pop_1d (sorted set with member=user:ts, score=ts, pruned via ZREMRANGEBYSCORE) for a sliding 24h popularity counter — all in a single pipelined round trip per event.

The Feature API (FastAPI) serves online reads from Redis via pipelined HGETALL + LRANGE + GET in one round trip, consistently achieving sub-5ms latency. Offline Parquet reads support point-in-time training access by run_date. The /metrics endpoint merges Parquet sidecar metadata, PostgreSQL partition records, Redis memory stats, and live pipeline status — providing the monitoring dashboard with a unified observability view. The same FeatureClient library is used on both the Airflow write path and the FastAPI read path, eliminating training-serving skew entirely.

Overview: RetailVault is an enterprise-grade retail data warehousing and analytics platform migrated to Microsoft SQL Server 2022, designed to demonstrate production-level T-SQL development, stored-procedure-driven ETL, columnstore indexing, and star-schema warehousing across dual SQL Server databases.

Technical Explanation: Built with a React frontend and Spring Boot backend, the platform uses two SQL Server 2022 databases — RetailVault_OLTP (transactional source) and RetailVault_Warehouse (star schema). All analytics and ETL logic lives in T-SQL stored procedures (usp_RunEtlPipeline, usp_GetKpiSummary, usp_GetMonthlySales, etc.), with Java acting as a thin JDBC wrapper via CallableStatement. Features include SCD Type 2 dimension tracking, a Nonclustered Columnstore Index on fact_sales for OLAP scan performance, window functions (DENSE_RANK, ROW_NUMBER, SUM OVER), TRY/CATCH transaction management, computed persisted columns, and a dual-datasource Spring Boot config with separate connection pools for OLTP and Warehouse. Deployed on Azure SQL + Railway.

Overview: A DBA-level query performance tuning case study on the RetailVault Azure SQL warehouse (100k rows), reducing total execution time from 41 seconds to 3 seconds (92.5% improvement) across 7 stored procedures — covering execution plan analysis, advanced indexing, engine internals deep-dive, and automated index maintenance.

Technical Explanation: Analyzed actual execution plans to identify table scans, key lookups, and parameter sniffing. Designed 7 targeted indexes (covering nonclustered, filtered, composite) with INCLUDE columns across 4 tables. Rewrote correlated subqueries as CTEs, replaced cursors with set-based OUTER APPLY logic, and applied OPTION(RECOMPILE) to fix parameter sniffing on inventory turnover — cutting that query by 94.1% (11,618 ms → 692 ms) and reducing dim_product logical reads by 95% (40 → 2). Authored a bonus engine internals module querying sys.dm_os_buffer_descriptors, sys.dm_exec_query_stats, sys.dm_os_wait_stats, and sys.dm_db_missing_index_details — confirming zero missing index gaps, 1.5% transaction log utilization, and all procedures cached with no blocking or I/O pressure. Also built usp_MaintainIndexes and usp_GetIndexHealth using sys.dm_db_index_physical_stats for automated rebuild/reorganize based on fragmentation thresholds.

Overview: StockBase is a full-stack inventory management system designed to help businesses manage products, suppliers, categories, stock movements, low-stock alerts, reporting dashboards, and exportable inventory records from one centralized platform.

Technical Explanation: The system is built with React, Spring Boot, and PostgreSQL using a multi-tier cloud architecture across Netlify, Render, Docker, and Neon PostgreSQL. It implements JWT authentication, role-based access control, RESTful API design, Spring Security, backend validation, relational database modeling, inventory transaction auditing, Recharts-based analytics, CSV export workflows, and separated frontend-backend-database deployment layers for production-style scalability.

Overview: SoonerBoomer-ERC20-dApp is a decentralized token claiming application that allows eligible users to securely claim ERC-20 rewards through a Web3 interface connected to their crypto wallet.

Technical Explanation: The platform uses Solidity smart contracts, OpenZeppelin ERC-20 standards, Hardhat deployment workflows, Ethers.js blockchain interaction, and MetaMask authentication. It implements Merkle tree-based allowlist verification to validate claim eligibility cryptographically without storing every wallet address on-chain, reducing storage costs and improving scalability for large reward distribution campaigns.