Aryan Anand

CV

Download PDF

Experience

Software Development Engineer – R&D

June 2025 – Present

Ninestars Information Technologies, Bangalore

  • Architected the backend of AOTM FDI, a multi-tenant credential-fraud detection platform live with a global credential-evaluation organisation that has processed 50K+ documents: a 5-stage OCR-to-clustering pipeline over RabbitMQ quorum queues and five queue-specialised Celery pools (11 Django apps, 119 REST routes, 43 tables).
  • Made the pipeline safe under at-least-once delivery, so a redelivered message never duplicates results or triggers the next stage twice: per-template fan-out joined by a row-locked fan-in barrier that releases exactly once, idempotent replace-scoped writes, and presigned per-object MinIO URLs so workers hold no storage credentials.
  • Built the fraud rules engine so unverifiable evidence can never pass a check and cost stays at ~7 queries per docket at any rule count: a depth-bounded boolean DSL (20 typed fields × 14 operators) validated at write time, three-valued evaluation that marks them unevaluable, and Gemini-rephrased reasons verified before display.
  • Made fraud verdicts independent of worker timing: weighted rule failures and visual-anomaly severity are scored 0–100, banded on per-customer thresholds and recomputed in one transaction as late evidence lands.
  • Checked each credential against the template its institution issued for that award year: versioned master-template generations per institution, credential and year, matched on perceptual hashes (pHash/dHash) and embeddings of seals, logos and signatures, ranked by per-document verdicts, with byte-identical copies excluded by SHA-256.
  • Ensured no docket gets a verdict on incomplete evidence by gating evaluation on required documents, fields and a matching master; built bulk reprocessing as cancellable Celery-beat jobs with dry runs and row locks, where a restart from any stage first proves every earlier stage finished on each document's last run.
  • Gave reviewers a live case queue: HTTP QUERY list APIs with multi-value filters and score ranges and sorts, WebSocket progress streams, optimistic-locked co-editing over Django Channels, and PDF/Excel reports.
  • Enforced fail-closed multi-tenancy across 33 tables, so a tenantless query raises instead of leaking rows: ContextVar-scoped managers, RBAC rank guards, rotating JWT sessions and AES-256-GCM export encryption.
  • Built the multi-tenant rate-limiting and usage-billing layer that meters AOTM OCR in production: atomic Redis Lua admission (token bucket + per-minute/hour/day windows), hierarchical user/project limits, two-phase credit reservation mirrored in Postgres with an orphan-reservation sweeper, and oversized batches trimmed to the user's affordable cap instead of rejected; admission takes under 5 ms with zero Postgres queries on a cache hit.
  • Built a database migration agent that moved 800M+ rows (100+ GB) for one customer from its on-prem servers, machines and VPSs straight to S3: a long-running daemon (Unix-socket IPC, thread pools resized from backend config) doing parallel batch extraction, with live progress and graceful stop, like a server-side Celery task.
  • Built hybrid semantic search (dense + sparse vectors fused by RRF over Qdrant, Jina Embeddings, self-hosted LLMs) used in production by AOTM FDI and Vault, with typical queries under 800 ms over 100K+ files.
  • Prototyped a private blockchain ledger (Proof-of-History consensus, Merkle-root block validation) for on-chain document signing and verification, giving tamper-evident audit trails.
  • Built the ML pipeline of AOTM PCI, a production sensor platform for museums and heritage collections that has run 10,700+ inference jobs across 2,500+ runs, raising 3,300 conservation risks and 3,900 LLM insights: each sensor uplink fans out across 10 RabbitMQ quorum queues (forecast, anomaly, LLM insight, photogrammetry, CFD) and rejoins on a fan-in barrier (row locks, on-commit publishing, UUIDv5 idempotency keys).
  • Added CFD and photogrammetry as async job types (design snapshots frozen under row locks, worker uploads registered by deterministic file IDs) and synced floor geometry to sensor placement, so sensors are ranked by 3D distance to each artifact; asset links are re-signed per request, so a storage move needs no data migration.
  • Built the telemetry layer on TimescaleDB hypertables (composite time + UUID keys) behind one GraphQL API for historical, forecast and anomaly reads across sensor, zone, floor and building scopes; it holds 3.6M rows from 119 days of continuous ingest and serves 50K-row, 30-day windows in ~250 ms.
  • Caught 3 of 16 sensors failing while the static config reported 97% fleet health, by deriving battery depletion (30-day regr_slope projection), persistent weak links (p10 RSSI) and dropout gaps from raw telemetry in SQL.
  • Architected AOTM Vault, a multi-tenant secrets-management platform in production with 2 customers: 50+ cryptographic algorithms (including post-quantum), one storage interface over AWS, Azure and Google Cloud, automated policy-driven key rotation on Celery, real-time WebSocket file streaming, and immutable audit logs.
  • Owned delivery: a 5-process Docker Compose topology (ASGI, beat, three queue workers), Jenkins CI with 70 scripted test suites, and an idempotent setup script that health-checks Postgres, Redis, RabbitMQ and S3 and provisions vhosts and quorum queues from the app's queue definitions, so broker topology cannot drift from code.

Machine Learning Intern

Sept 2023 – Dec 2023

TIH IoT & IoE, IIT Bombay, Mumbai

  • Built a U2-Net pipeline for automated image masking and trained CNNs for vegetation segmentation on NDVI and hyperspectral imagery, covering preprocessing, augmentation and hyperparameter tuning for deployment.

Education

Vellore Institute of Technology

CGPA: 8.24/10

Bachelor of Technology in Computer Science and Engineering · 2021 – 2025

Technical Skills

Languages

  • Python
  • Go
  • SQL
  • TypeScript
  • JavaScript
  • Java
  • Kotlin
  • C++
  • Bash
  • HTML
  • CSS

Backend & APIs

  • Django
  • Django REST Framework
  • Django Channels
  • FastAPI
  • Flask
  • asyncio
  • gRPC
  • GraphQL
  • REST
  • WebSockets
  • Node.js
  • Express.js
  • ASGI/Uvicorn

Frontend & Mobile

  • Next.js
  • React
  • React Native
  • Expo

Data & Messaging

  • PostgreSQL
  • TimescaleDB
  • MySQL
  • MongoDB
  • Redis/Valkey
  • Redis Streams
  • Qdrant
  • Celery
  • RabbitMQ
  • Apache Kafka
  • Pub/Sub

Cloud & Storage

  • AWS (S3, EC2, Lambda)
  • Google Cloud (Cloud Storage)
  • Azure (Blob Storage)
  • MinIO

DevOps & Testing

  • Docker
  • Kubernetes
  • Jenkins
  • GitHub Actions
  • GitLab CI/CD
  • Prometheus
  • Grafana
  • OpenTelemetry
  • pytest
  • Hypothesis
  • Toxiproxy
  • Git
  • Linux
  • VMware

AI/ML

  • PyTorch
  • TensorFlow
  • Keras
  • HuggingFace Transformers
  • Llama
  • RAG
  • Jina Embeddings
  • OpenCV
  • scikit-learn
  • NumPy
  • Pandas
  • NLTK

Projects

odin

2026

Python, gRPC, PostgreSQL, RabbitMQ, Valkey, FastAPI, Next.js, Docker, OpenTelemetry

  • Built a durable workflow engine from scratch in Python (asyncio, gRPC, asyncpg): workflows are plain async functions whose event-sourced history in PostgreSQL is replayed deterministically, so any engine or worker process can be killed at any line without losing a run or repeating a finished step's side effects.
  • Designed a 3-node cluster that splits 64 shards by rendezvous hashing under 10-second leases with range-ID fencing, so a node that lost its lease can never commit; failover takes about 9.5 s.
  • Made side effects safe under at-least-once delivery: history, timers and tasks commit in one transaction, a transactional outbox publishes to RabbitMQ quorum queues, staleness checks drop duplicate tasks, and idempotency keys with saga compensation (refunds, stock release) hold even when a run is canceled mid-step.
  • Built a chaos runner (Docker API, Toxiproxy) with 10 fault scenarios, including node kills and pauses, network partitions, broker and database outages, and payment faults, plus an invariant checker for lost runs, double charges and stale-owner writes; a 1-hour soak closed 3,626 runs on time, absorbed 86 retries and charged no order twice.
  • Added admission control (per-origin quotas, a queueing-delay limit, backlog caps), Prometheus, Grafana and OpenTelemetry traces that follow a run across the outbox, and a live Next.js dashboard over SSE; covered by 270 unit tests including Hypothesis property tests of replay, plus integration and end-to-end suites in CI.

hermod

2026

Go, Python, NumPy, PyArrow, OpenStreetMap, Valkey, OSRM, Docker, GitHub Actions

  • Built a ride-dispatch engine in Go with a standard-library-only core on a 36,108-node OpenStreetMap road graph of Manhattan: Dijkstra, A* and a bounded reverse one-to-many search that times a request's 20 nearest drivers by road in 0.79 ms, with route lengths within 0.04% of OSRM's in the median.
  • Wrote an in-process uniform-grid index with per-cell locks and per-driver compare-and-swap claims, so concurrent matchers never double-book a driver; it finds the 20 nearest idle drivers in 1.69 s, 62× faster than Valkey GEOSEARCH over loopback (16× on server time), and road-time re-ranking changes about half of all picks.
  • Replayed 76,312 NYC taxi requests from 2010 rush hour through a seeded discrete-event simulator with byte-identical reruns and travel times calibrated to the taxis' recorded durations by hour (median ratio 0.995–1.02); 10-second Hungarian batch matching (rectangular, fuzzed against brute force on 3.8M matrices) served 49% more riders than greedy at 2,000 drivers and cut median pickup ETA from 6.0 to 0.8 min.
  • Verified every run with an invariant checker that reads only the event log (one driver per trip, no offers to offline drivers, every request ending once) over 150 seeded runs, plus fuzz oracles, the race detector and 39 planted bugs, all caught; traced an implausibly large batching gain to minute-rounded timestamps in half of the taxi data.

nukeit

2026

TypeScript, React Native, Expo, Kotlin, SSH (JSch), Android Widgets, Next.js, S3

  • Built an Android app that runs saved scripts and keyboard shortcuts on the user's own Linux, macOS and Windows machines over SSH in one tap, from the app or a 4-button home-screen widget, with no backend or account.
  • Wrote the native layer as a local Expo module in Kotlin on JSch (password and keyboard-interactive login, deadline-bound exec, background widget runs via goAsync), and caught R8 stripping JSch's reflectively loaded ciphers out of a release build that compiled cleanly by inspecting the APK's dex, fixed with keep rules.
  • Made commands reliable over the internet: sessions idle past 15 s are probed and reopened before a command starts, a failed command marks its session unproven instead of dead, reachability tries ICMP then TCP on the machine's SSH port, and a run past 2 minutes is reported as possibly still running rather than failed.
  • Pressed shortcuts on each OS from one unit-tested TypeScript mapping: xdotool on X11, AppleScript System Events on macOS, and a one-off scheduled task in the signed-in Windows session via a UTF-16LE -EncodedCommand; dangerous scripts need a slide-to-confirm gesture in the app and a second tap on the widget.
  • Shipped a Next.js 16 product site with real app screens captured by an emulator pipeline (SQLite-seeded app storage, iptables DNAT to a paramiko demo SSH server), and an invite-only download gate: Cloudflare Turnstile first, then a timing-safe invite-code check, then a presigned S3 link with a pinned SHA-256.

Python, Flask, PyTorch, TensorFlow, Llama, React, Hugging Face

  • Built a medical-imaging web app that upscales MRI and CT scans with an SRGAN, translates between MRI and CT with a CycleGAN, and classifies brain and lung scans with fine-tuned ResNet-50 models on Hugging Face.
  • Added a Llama 3.2 assistant that explains a detected condition and answers follow-up questions in plain language.

Python, TensorFlow, Keras, OpenCV, gTTS, Git

  • Built a real-time sign-language-to-speech app: OpenCV isolates the hand, a Keras CNN trained on 17,113 hand-sign images (27 classes) classifies it at 99.9% validation accuracy on a 30% hold-out, and gTTS speaks the result.

Certifications and Achievements