name: Vishnu Sangadala
role: Software Engineer
focus: [Java Backends, C++ Systems, CUDA, Distributed Systems, AI Automation]
experience: 2+ years
education: MS in Data Science — Stony Brook University
currently_building: reliable systems where performance and intelligence meetI design software across three layers: services that scale, native code that moves fast, and automation that can reason about an interface before acting. My work ranges from Spring Boot microservices and Kafka pipelines to custom CUDA kernels and voice-driven Windows automation.
Click a card to open the repository. Expand a build note below for the engineering story.
|
|
|
|
⚡ Build note: CUDA Image Processing Accelerator — what makes it more than a demo
The application implements grayscale conversion, Gaussian blur, and Sobel edge detection through matched C++/OpenCV and custom CUDA paths.
- Shared-memory halo tiles and constant-memory Gaussian coefficients
- CUDA-event timing split into transfer, kernel, and download phases
- CPU/GPU maximum-error validation, including non-block-aligned images
- Multi-resolution benchmark runner with CSV output
- CMake presets, development container, tests, and CPU-only CI
image ─┬─> C++ / OpenCV reference ──────────────┐
└─> upload ─> CUDA kernel ─> download ───┼─> verify + benchmark + report
🏦 Build note: CreditFlow AI — deterministic finance inside an agentic workflow
Five agents extract loan terms, calculate risk ratios, assess risk, draft a credit memo, and verify the result. Financial calculations stay in deterministic Python; questionable cases stop at NEEDS_REVIEW for a human decision.
flowchart LR
D[Loan document] --> E[Extraction agent]
E --> M[Deterministic metrics]
M --> R[Risk + memo agents]
R --> V{Verifier}
V -->|pass| A[Audited result]
V -->|flag| H[Human review]
Java 21 · Spring Boot · PostgreSQL · Python · FastAPI · LangGraph · React
📊 Bonus build: LLM Inference Benchmark — performance claims with evidence
A reproducible benchmark for vLLM and PyTorch/Transformers across batch sizes, prompt lengths, and generation lengths. It records TTFT, inter-token latency, throughput, GPU utilization, and peak GPU memory, then exports raw JSON/CSV and Prometheus metrics.
I build Java 17/21 services with Spring Boot, explicit API contracts, and ownership boundaries that stay understandable as a system grows.
| Design concern | How I approach it |
|---|---|
| Service boundaries | Independent services and data ownership instead of shared persistence |
| Communication | REST for direct requests; Kafka for asynchronous domain events |
| Data | PostgreSQL for relational content, Neo4j for graph relationships, Redis for low-latency access |
| Reliability | Validation, DTO boundaries, testable service layers, audit trails, and visible failure states |
| Delivery | Maven, Docker, Kubernetes, CI/CD, and reproducible local environments |
flowchart LR
U[user-service] -->|follow event| K((Kafka))
P[post-service] -->|post / like event| K
K --> F[feed-service]
U --> N[(Neo4j)]
P --> G[(PostgreSQL)]
I use modern C++ and CUDA when latency, throughput, and memory behavior are part of the product—not implementation details.
- Native C++17 design with CMake and clear CPU/GPU abstractions
- Custom kernels, coalesced access, shared-memory tiling, and CUDA event timing
- Correctness comparisons before performance claims
- Warmups, repeated measurements, raw artifacts, and hardware-aware reporting
My rule: benchmark the complete path, publish the method, and never invent the speedup.
My Windows desktop agent converts spoken requests into inspectable UI actions. Rather than guessing coordinates, it grounds each decision in the live accessibility tree.
flowchart LR
V[Voice] --> W[Faster Whisper]
W --> L[LLM planner]
T[Live UI tree] --> L
L --> J[Structured JSON action]
J --> P[PyWinAuto]
P --> T
The loop performs one action, reads the interface again, and continues only from the updated state. Hotkey recording, a tray interface, and spoken feedback make it usable as a desktop assistant.
Python · LangChain · LangGraph · Faster Whisper · Windows UIA · PyWinAuto
CUDA · vLLM · LangGraph · Neo4j · Prometheus · REST APIs · Microservices · CI/CD
My engineering operating system
01 Make ownership explicit 04 Measure before optimizing
02 Keep deterministic logic testable
03 Verify probabilistic output 05 Leave an evidence trail
