Parth Kathuria

Senior Software Engineer · Open to opportunities

Hi, I'm Parth Kathuria.
I build distributed systems at scale and AI-native developer tooling.

Senior software engineer with 10+ years across platform modernization, developer tooling, and large-scale distributed systems — from agentic pipelines to real-time telemetry across 650k+ devices.

View my work → Get in touch
10+ yrs
shipping production software
650k+
devices monitored at scale
15×
faster clean builds
$20k/yr
infrastructure saved
01Projects

Things I've built.

Projects I worked on or led across AI-native tooling, language infrastructure, and distributed systems at scale. Tap any tile to expand the details.

Topic Modernization — TurboTax Interview Screens

Built the artifact-generation pipeline that drove migration of TurboTax interview screens from Intuit's legacy DSL to modern TypeScript on Fuego Player (React) — cutting medium-complexity migration from 1–2 weeks to 1–2 days.

  • Topic Modernization
  • TypeScript
  • Fuego Player (React)
  • AI Compliance Audit
  • Developer Tooling
Problem
TurboTax's interview screens ran on Intuit's legacy proprietary DSL. The company-wide Topic Modernization program was rebuilding them as modern TypeScript rendered in Fuego Player, Intuit's React-based screen player. Migration was slow and manual, and the legacy flows didn't always encode IRS compliance directly — it was enforced in a separate process — so the new screens had to be verified against IRS rules as they were built.
Approach
I led the effort behind the pipeline that generates the inputs the new screens are built from. A deterministic stage parses the legacy interview code and produces three artifacts per Topic — the complete screen flow, the language files, and a Markdown migration report — and AI prompts then audit those screens for IRS compliance and generate an audit report. I owned the deterministic stage and built several of the AI compliance prompts, and the artifacts flow to the teams creating the new TypeScript / Fuego Player screens. This deterministic-then-AI pattern was proven here first, then reused on the Form Conversion Service.
Architecture
A deterministic parser over the legacy interview DSL emits, per Topic, the screen flow, the language files, and a Markdown migration report. Those artifacts feed AI prompts that audit IRS compliance and output an audit report, all consumed downstream by the teams building the new TypeScript / Fuego Player screens. MCP plays a small supporting role, giving the AI agents better context for the audit.
Impact
Delivered ready-to-use migration inputs — screen flow, language files, migration and compliance-audit reports — that cut medium-complexity screen migration from roughly 1–2 weeks to 1–2 days, the primary driver of the program's acceleration.

The leverage came from generating inputs the migration teams could trust. Deterministic parsing produced the screen flow, language files, and migration report; AI then audited those screens for IRS compliance and wrote the audit report. Getting compliance right was the hard part — the legacy flows leaned on a separate process to enforce it — and automating that audit is what turned a 1–2 week effort into 1–2 days. The pattern proved out here, then carried over to FCS.

Form Conversion Service (FCS) Modernization

Led the productionization of a new DSL that replaces FCS's legacy XML/XSLT conversion to the IRS MeF data model — owning the XML→DSL migration and the user tooling. 15× faster clean builds (60s → 4s).

  • FCS
  • DSL Productionization
  • LSP
  • IRS MeF
  • AI-Assisted Migration
Problem
The Form Conversion Service (FCS) converts Intuit's XML tax data into the IRS MeF (Modernized e-File) data model. The legacy architecture relied on custom XSLTs and mappings — verbose, slow to build (60s clean builds), and without real editor tooling. Moving FCS onto a new DSL meant making the language production-ready, migrating the legacy XSLTs onto it, and giving authors the tooling to work in it.
Approach
I led the effort end to end — productionizing the DSL and its toolchain, driving the migration of the legacy XML/XSLT onto the new DSL, and building the tooling authors needed, including LSP-based editor support for real-time diagnostics and validation. For the migration I reused the deterministic-then-AI approach proven on Topic Modernization — a deterministic XML-to-DSL conversion first, then AI prompts to enhance the output, with quality checks and self-correction.
Architecture
The DSL compiles through its own toolchain, which I hardened for production and fronted with Language Server Protocol (LSP) integration so authors get diagnostics and validation in any LSP-capable IDE. The DSL performs the XML-to-IRS-MeF conversion that custom XSLTs handled before. Migration runs a deterministic XML-to-DSL stage, then AI enhancement with self-correction; MCP plays a small supporting role, giving the AI agents better context.
Impact
15× faster clean builds — 60 seconds down to 4 — plus a production-ready DSL, an LSP authoring experience, and a working XML→DSL migration path off the legacy XSLTs.

Productionizing a language is its own discipline. I fronted the toolchain with an LSP server so the editor and the compiler share one definition of “valid” — authors get diagnostics as they type instead of failing late in a build. Pairing that with the deterministic-then-AI migration gave a fast, legible path off the legacy XSLTs and onto a DSL that both humans and AI agents can target.

IDE-Native Developer Tooling (VSCode Extensions)

Unified diagnostics, deployment, and localization authoring into VSCode extensions — projected +30% and measured +50% developer productivity.

  • VSCode Extension API
  • MCP
  • Developer Experience
  • Tooling
Problem
Tax developers were context-switching across scattered command-line tools and web dashboards to diagnose, deploy, and author form localization (NLS) files. The localization workflow in particular was a recurring source of malformed JSON that only surfaced downstream, costing real time and trust.
Approach
I led end-to-end delivery of IDE-native tooling that brings the work to where developers already are. Rather than another external dashboard, the diagnostic and deployment workflows became a single in-editor experience, and the localization authoring tool validated JSON in real time as developers typed — backed by MCP integration so the editor has the context it needs.
Architecture
VSCode extensions built on the VSCode Extension API. One unifies diagnostic and deployment tooling into a single IDE-native surface. A second authors and validates NLS localization files with real-time JSON error detection and Model Context Protocol (MCP) integration, catching malformed JSON at author time instead of in a downstream pipeline.
Impact
The unified diagnostic/deployment extension is projected to raise developer velocity by 30%. The localization extension eliminated a critical class of malformed-JSON errors and increased tax-developer productivity by 50%.

The theme across both extensions: meet developers in the editor, validate at the moment of authoring, and kill whole error classes before they enter a pipeline. Real-time JSON validation on the localization files didn’t just speed people up — it removed a recurring source of downstream failures entirely, which is worth far more than the raw productivity number suggests.

Tax-Calculation Authoring Tool on AWS

Architected an event-driven authoring & debugging tool on AWS — then led its strategic deprecation, saving ~$20k/yr.

  • AWS
  • Event-Driven
  • Lambda / ECS
  • Infrastructure-as-Code
Problem
Authoring and debugging tax calculations was slow and opaque. The team needed a faster way to author calculation logic and inspect its behavior, without standing up and babysitting long-lived infrastructure.
Approach
I architected an event-driven microservice system on AWS so the tool scaled with demand instead of running idle capacity. Later, when usage and the surrounding platform shifted, I made the harder, less glamorous call — rather than keep a system alive for its own sake, I led its strategic deprecation and migrated off it cleanly.
Architecture
An event-driven microservice architecture on AWS — Lambda for compute, ECS for longer-running workloads, EventBridge for event routing, and CloudFormation for reproducible infrastructure-as-code. The event-driven design kept the system responsive under bursty authoring workloads without paying for idle capacity.
Impact
Delivered a working authoring-and-debugging capability on a scalable, reproducible AWS footprint — and, when it was the right decision, retired it cleanly to save approximately $20,000 per year in infrastructure cost. Knowing when to sunset a system is as much engineering as building it.

The part I’m proudest of here isn’t the build — it’s the deprecation. It’s easy to let a system you architected live forever. Recognizing that the platform had moved on, then leading a clean migration off it to save ~$20k/yr, was the higher-leverage decision. Good engineering includes subtraction.

Print-Engine Migration to GraalVM Native Image

Migrated the tax-form print engine off a legacy Java→.NET bridge to a GraalVM native image for Java 11, coordinated across TurboTax Desktop and ProSeries.

  • GraalVM
  • Java
  • Native Image
  • Cross-Team Delivery
Problem
The tax-form print engine ran through a legacy Java-to-.NET bridge (IKVM) that blocked a Java 11 upgrade and tied two major desktop products to an aging, hard-to-maintain interop layer. Staying put meant carrying that liability indefinitely; moving meant touching a component both TurboTax Desktop and ProSeries depend on to render correct tax forms.
Approach
I led the migration from the IKVM bridge to a GraalVM native image, getting the engine to Java 11 compatibility while preserving exact print output. Because the engine is shared, the work was as much cross-team coordination as it was code — sequencing and validating delivery across two product lines that could not afford print regressions.
Architecture
Replaced the Java→.NET (IKVM) interop bridge with a GraalVM native image of the print engine, eliminating the bridge layer and unblocking the Java 11 upgrade. Delivery was coordinated across the TurboTax Desktop and ProSeries teams so both consumed the new engine without regressions in rendered output.
Impact
Removed a long-standing interop liability, brought the print engine to Java 11, and shipped the change across two flagship desktop products without breaking print fidelity — turning a blocked upgrade into a clean modernization.

Shared components are the scariest things to modernize: the blast radius spans every product that depends on them. The technical move — IKVM bridge to GraalVM native image — mattered, but the reason it shipped without incident was the cross-team sequencing and validation across TurboTax Desktop and ProSeries. Print fidelity is non-negotiable in tax software; the migration had to be invisible to the end product.

Telemetry Pipeline at 650k+ Devices

Built a distributed pipeline collecting real-time telemetry from 650,000+ solar trackers worldwide, with a 99% uptime database migration.

  • Distributed Systems
  • IoT
  • Time-Series
  • AWS
  • CI/CD
Problem
A global solar fleet of 650,000+ trackers needed real-time monitoring and remote control. The telemetry had to be reliable enough to drive operational decisions and feed a proprietary predictive tracking algorithm — at a scale where backpressure, partial failure, and schema drift are constant, and where the fleet can't tolerate maintenance windows.
Approach
I built the data pipeline end to end — edge collection, ingestion, storage, and a monitoring/configuration dashboard for both internal teams and customers — and designed the IoT data-management device that anchors collection at the edge. I also automated the configuration and deployment of the predictive tracking algorithm so rolling it out stopped being a manual, error-prone chore.
Architecture
Edge devices stream telemetry into a scalable distributed pipeline backed by a time-series database, which I migrated from a single instance to a VM + Docker hybrid cluster while holding 99% uptime. A REST API exposes metrics to the Data Analytics team, and Jenkins CI/CD automates build, test, and deployment across the toolchain.
Impact
Real-time visibility and remote control across 650,000+ devices, a 60% reduction in predictive-algorithm deployment time via automated configuration, and a live database migration completed at 99% uptime — no maintenance window the fleet couldn't afford.

This is the systems-at-scale counterweight to the tooling work. Telemetry from hundreds of thousands of devices is unforgiving about backpressure, partial failure, and schema drift — the failure modes are statistical, not anecdotal. Migrating the time-series database to a hybrid cluster at 99% uptime was the proof the pipeline could evolve without a maintenance window the fleet couldn’t afford.

Also shipped

  • PDF Field-Name Standardization Tool Tooling

    Restored original field designations across ~3,000 PDFs converted with Foxit Editor, spanning 300 agency repositories, and streamlined the cleanup workflow.

  • Java 21 & React 18 Upgrades Operational Excellence

    Completed Java 21 and React 18 upgrades for all owned services ahead of mandate deadlines, achieving full compliance on the internal production-readiness dashboard.

  • Solar Telemetry Collection & Dashboard (Internship) Early Work

    Built a remote tracker data-collection automation over TCP/IP and a Node.js data-visualization dashboard deployed on AWS.

02Toolbox

Skills & technologies.

A decade across languages, AI tooling, cloud platforms, and data systems.

Languages

Java
Go
Python
TypeScript
JavaScript
Node.js
C
C++
C#
Bash

AI & Tooling

Model Context Protocol
Language Server Protocol
VS Code Extensions
Claude
Cursor
GPT Codex

Cloud & DevOps

AWS
Azure
Docker
GraalVM
Jenkins
ArgoCD
Git

Data

PostgreSQL
InfluxDB
MySQL
SQL Server
Redis

Frameworks

Spring
React
Django
Express
03About

About me.

I'm a software engineer with a proven history of leading platform modernization, defining technical direction, and building high-impact developer tooling across organization-wide programs. My focus is making complex migrations safe and fast — pairing deterministic engineering with AI where it earns its place, and measuring quality instead of trusting it.

My work spans agentic AI pipeline design, AI-ready language architectures with LSP integration, distributed data pipelines, and event-driven microservices on AWS.

04Contact

Let's build something.

Open to senior and staff engineering roles across distributed systems, AI infrastructure, developer tooling, and platforms.

parthkathuria09@gmail.com