Saviynt systems are internal. Shown here through numbers and write-ups. Personal work links out to code. Full technical write-ups under /blog.
LICENSE INTELLIGENCE· internal systemlive inference
License waste, found and removed
Companies pay SAP per user, priced by access level. Most quietly overpay for dormant accounts and over-privileged users. I built the inference engine that finds this waste. It reads access data and infers savings opportunities, any number of accounts or identities, with dollar figures attached. Then it acts on them, creating removal tasks with records that survive the nightly data refresh. Validated 51/51 against live APIs, through two rounds of senior review.
JavaSpring BootKafka AvroOpenSearch
COMPLIANCE ENGINE· internal system21h → ~3 min
A day-long audit check, rebuilt to seconds
Large companies must continuously prove that no employee holds conflicting permissions. For example, the ability to both create and approve the same payment. Running this check across hundreds of thousands of accounts took one customer 21 hours, because the old system re-examined the organization hierarchy separately for every rule. I rebuilt the engine to resolve the hierarchy once and compare permissions with bit-level operations. Compute fell to 2 seconds in 256 MB, and with database writes the whole job now finishes in about 3 minutes. Output identical, row for row.
JavaRaw JDBCBitSetOpenSearch
DATA EXPORT· internal systemunbounded · 7 MB flat
Million-row reports that fit in 7 MB
Audit and compliance teams periodically need complete data exports. Millions of rows formatted as Excel workbooks. The previous exporter assembled entire workbooks in memory and crashed on large reports, typically during audit season. I rebuilt it as a pipeline where each stage handles only a small window of data at a time. It reads, formats, uploads, and archives in a continuous flow, so memory stays flat at 7 MB. 15M+ rows proven in production, with no upper bound in the design.
JavaPOI SXSSFS3 multipartZIP streaming
DATA INGESTION· internal system50K+/s · 300 tenants
Audit records you can count on
Every privileged action on the platform becomes an audit record. Who accessed what, and when. These records feed fraud detection and regulatory audits, so none may go missing and none may be counted twice, across more than 300 customer organizations sharing the same infrastructure. I built the ingestion path with ordered, replayable streams and duplicate-proof storage, sustaining over 50,000 events per second and running unchanged across three cloud environments.
KafkaAvroMySQLRedis
AI SAFETY· internal system~22ms per check
The same fraud check, for AI agents
Companies now build AI assistants that hold tools, data access, and login credentials. These assistants can call other assistants or share credentials with them. The dangerous permission combinations we police in humans quietly reappear, with no person in the loop. I built an engine that examines each agent setup for five such patterns. A single over-privileged agent, conflicts spanning an agent and its owner's permissions, delegation chains between agents, credential-sharing groups, and actions taken on a user's behalf. Each setup evaluates in about 22 milliseconds, and every finding is tracked until it is resolved.
JavaSpring BootGraph analysisRaw JDBC
AI MONITORING· internal systemverified citations only
AI investigators with mandatory evidence
The most sensitive accounts in a company are emergency 'break-glass' administrator accounts, and their activity logs are where insider fraud appears. I built software agents that investigate these logs on their own. Each pursues one fraud hypothesis with a strict budget of steps and time, and any log entry it cites as evidence is automatically re-checked against the source data. Unverifiable claims are discarded, and uncertain findings go to a human reviewer. New fraud patterns are added through a configuration file, without changing code.
PythonReActElasticsearchYAML policies
SECURITY· internal systemcoverage 30% → 80%
Company-wide security initiatives
Twice in my first year I was asked to join temporary, company-wide security teams addressing systemic issues. Categories of injection and access-control flaws found across services, encrypted internal communication between data systems, and test coverage on critical components, which rose from 30% to 80%. The work was unglamorous and cross-team by design. It prevents incidents rather than responding to them.
AppSecmTLSSAST/DASTTesting
AI INFRASTRUCTURE
Send each request where its past already lives
less recomputation
When you continue a conversation with a large language model, the serving computers keep a cache of what came before, so follow-up questions avoid redoing work. But in a fleet of machines, a standard load balancer sends your follow-up to a random server, which recomputes everything. Nostos, a router I built, instead sends each request to the server whose cache already holds that conversation. It weighs cache overlap against queue length and memory load. It remembers fingerprints of past text, never the text itself, and passes responses through without buffering. A public demo lets you race routing strategies against each other.
GoRadix treesvLLM / TGIReact
LEARNING IN PUBLIC
A language model built by hand
no model libraries
To understand language models from the inside, I implemented a small one in PyTorch while deliberately refusing the framework's ready-made model components. Embeddings, attention, and decoder blocks all written out explicitly, each stage tested before the next. The model is tiny on purpose, so that internal quantities like the attention matrix stay small enough to read directly. Since ported to dependency-free C++17 as gpt2-cpp, with a five-test correctness harness. And since trained for real as lm-train: 0.818M params on Shakespeare, val loss 1.75.
PythonPyTorchTransformerspytest
LEARNING IN PUBLIC
The same model, one level deeper
in progress
Now the same transformer implemented directly in the graphics processor's own programming language, with every computation kernel written by hand. It starts from matrix multiplication checked against an ordinary CPU reference, moves through attention and normalization, and heads toward a full training run and an optimized attention variant benchmarked against PyTorch. The goal is a working understanding of how GPUs actually execute programs. Memory movement, parallel scheduling, occupancy. Not familiarity with an API, but with the machine. In progress; each phase must pass its tests before the next begins.
CUDAC++CPU referenceColab T4
Coursework-era builds, kept as-is. The habit predates the job titles. Rebuild it to learn it.