Bengaluru, India · QA engineer by day, founder by night
I build honest consumer products. And I test everything.
I'm Jay Chak — Quality Assurance Engineer at Amazon (Appstore & Fire TV) and founder of Elyxis, I'm Okay and LeadShala, and the builder of GlassBox, a browser agent you can watch and steer, Patchbay, a visual pipeline builder, and Cue, a real-time AI call copilot now in build — plus open-source PRs merged into career-ops and Signadot. I care a lot about products telling the truth — my flagship app is built to say "this didn't work for you" when that's what the data shows.
Six products, end to end. All built to tell the truth.
Designed, engineered and tested end-to-end — with Claude Code as my AI pair-programmer, and QA discipline from four-plus years at Amazon baked into every release.
E
Elyxis
A/B testing for humans — one change, honestly measured
YC F2026 applicantFlagship
An n-of-1 experimentation platform. Pick one change — magnesium for sleep, matcha instead of coffee — and AI designs a proper single-person trial: the right duration, a counterbalanced on/off schedule, one thirty-second question a day. Wearables sync in the background as covariates. At the end, a Bayesian engine returns an honest verdict with credible intervals — and says “no clear effect” when that's the truth. The wellness industry sells certainty it doesn't have; Elyxis is built to tell the truth about your own body.
Give it a goal in plain English and it drives a real browser to get it done — planning each step with an LLM in the loop, then navigating, reading, clicking, extracting and filling. The part I actually cared about: you can see every move it makes and take the wheel at any moment. Reasoning, the chosen action and a live screenshot of the page stream to the interface as it happens; a timeline rail marks each step green when it lands, red when it fails, and blue when a human stepped in. Most agents are a spinner and a shrug. This one shows its work — hence the name.
1 dayconcept to deployed, solo
14/14rows verified on the proven extraction run
0silent failures — every stall is diagnosed out loud
Publiclimitations doc + adversarial suite in the repo
A visual pipeline builder: drag typed nodes onto a canvas, wire the ports together, and an LLM workflow takes shape — the same way you'd patch signal through a studio rack, which is where the name comes from. The part I actually cared about is the node system underneath. Every node type — input, model, filter, an HTTP request, a note — is described as one small object: its fields, its ports, its colour. A shared factory turns that object into a working node, so adding a whole new node type is a few lines, not a new component. I built the front end, the dark design system, and the backend that checks the graph is valid — no loops — before it can run.
Every job-search tool computes its metrics from a date a human typed in from memory. Meanwhile the employer's own confirmation email — the one externally attested timestamp in the whole pipeline — sits unread in the inbox. Postmark picks it up: receipts with the employer's timestamp, an honest transition ledger every status change must pass through, a manual-apply queue, and BM25 recall over past application answers so the next form starts from what you already wrote. Runs on your laptop, reads your own files, sends nothing anywhere. Built beside career-ops, the open-source job-search agent I contribute to.
192automated tests — no test framework
0runtime dependencies — Node 20 only
127.0.0.1the only address it will ever bind
BM25answer recall over everything you've written
Node.jsZero depsNDJSON live streamingBM25Local-first
Cu
Cue
A real-time AI copilot for meetings, sales calls and interview prep
In buildTeam-led
Cue listens to a live call, transcribes it as it happens, spots the question being asked, pulls in context from your résumé, job description and documents, and streams a suggested answer into an overlay — targeting under 2.5 seconds to first token. The difference is an incremental pipeline: intent detection and context prefetch start on the partial transcript, not after the question ends. It's consent-first by spec: a normal overlay window, with no proctoring bypass and no "undetectable" claims. I'm leading the build with a team and AI agents.
A simple way to let your family know you're okay. Confirm a check-in on your schedule; miss it, and your trusted contacts are quietly told. Meal and medicine reminders included. No tracking, no panic, no countdowns — reassurance, not surveillance. Built in 40 languages — launching soon.
Started as a performance-marketing agency I ran solo for 6+ years — Google & Meta ads for local service businesses across India, the US, the UK and Australia. Sold cold, backed by a 30-day money-back guarantee, every function done myself: niche, outreach, landing pages, media buying. That's where I learned to find a market and talk to it. Now the parent company of Elyxis and I'm Okay.
It started personally: a genetic health issue in my family earlier in 2026 left me wanting honest answers about my own body — and every wellness app I tried sold certainty it didn't have. So I built the tool I couldn't buy.
The loop PRODUCT
Change one thing — magnesium for sleep, matcha instead of coffee — and rate one outcome daily. About five seconds.
Claude designs each protocol: the right duration, a counterbalanced on/off schedule, and it narrates the final report in plain English.
Wearables sync in the background as covariates — sleep, steps — so the model can adjust for confounders.
A confounder-adjusted regression + Bayesian verdict with credible intervals. Probability is capped at 99% — 100% would be a lie — and it says “no clear effect” when that is the truth.
99%likely helped · +3.2 sleep points · CI +0.9 to +5.4 · 12 valid days — first live verdict on production data, 25 Jul 2026, with the model refusing to overclaim
Architecture — built solo STACK
React Native + Expo — Android and iOS from one codebase.
Next.js marketing site and operator dashboard.
Supabase Postgres with row-level security (EU region) + Deno edge functions for orchestration.
Stateless Python FastAPI statistics service — only de-identified numeric arrays reach it, it retains nothing, and raw samples sit on a 90-day purge schedule.
Paddle as merchant of record — the live payment path closed its final audit with zero criticals and zero majors.
The server holds all authority; the client is never trusted. GDPR-grade export and deletion, built in from day one.
The quality bar — a QA engineer's startup TESTING
~1,800automated tests, green before any merge
13property-based invariants, run at 100+ random iterations
6report-only red-team passes (OWASP Top 10 2025)
6ecosystem audits across the whole stack
0criticals or majors on the live payment path's final audit
20signed design canvases — nothing merges until the built screen matches, on-device, light & dark
I build by directing AI coding agents — Claude Code as the daily driver. The agents produce, I decide: architecture, scope, security, final acceptance.
Public launch is weeks out — Y Combinator Fall 2026 applicant. The demo account is sandboxed; poke around.
A browser agent — in full
GlassBox, every detail.
I kept watching AI agents do impressive things behind a loading spinner, and realised the hard problem isn't autonomy — it's trust. If a person can't see what an agent is doing, they can't correct it, and they won't use it for anything that matters. So I built the agent I'd actually let near real work: one that narrates every decision and hands you the wheel whenever you want it.
What it does PRODUCT
A goal in plain English — no scripts, no selectors, no recorded macros. You type what you want.
The model plans and acts, step by step: navigate, read, click, extract, fill. Each action is chosen at runtime from what's actually on the page, then re-planned from the result.
Everything streams live — the reasoning behind each step, the action taken, and a screenshot of the page as it stood. Over WebSocket, as it happens.
You can stop it, approve a step, or step in yourself at any point, and the run picks up from where you left it.
It ends with a clean, structured result — a table, a brief, a confirmation — not a wall of logs.
14/14rows extracted and verified on the proven invoice run — executed twice, end to end, against the live model
Architecture — built solo STACK
Playwright driving a real Chromium session server-side — a genuine browser, not a fetch-and-parse imitation.
Python + FastAPI backend running the plan/act loop and orchestrating the model.
WebSocket step-streaming pushes reasoning, action and screenshot to the UI the moment each occurs.
Claude API as the reasoning layer, with the loop re-planning against real page state after every step.
Railway for deployment, with a version marker baked into the backend so a deploy is confirmed, never inferred from a page that might be cached.
Design and build directed end to end by me — Claude Design for the interface language, Claude Code for implementation, every architectural and acceptance call mine.
The interface is the product DESIGN
An agent is only as useful as your ability to see what it's doing and take it back. So the interface got the most attention, not the least.
A timeline rail with numbered nodes — green when a step lands, red when it fails, blue when a human intervened, and a pulsing node while it's mid-action. The whole run is legible at a glance, after the fact as well as during.
Glass panels on a deep-space grid, mint accent with state-coloured glows, JetBrains Mono and Instrument Sans — built so a non-technical person watching over your shoulder can follow along.
Failure is narrated, never swallowed. When a run can't proceed, it says exactly what blocked it and why, in words a person can act on.
1 dayconcept to deployed and public, solo
3working task presets, each honest about its own status
0silent failures — every stall is diagnosed out loud
PublicLIMITATIONS doc shipped in the repo, not hidden
Promptinjection suite — the failure mode unique to browser agents
Runnableadversarial tests anyone can execute themselves
How I test an agent I don't fully control TESTING
Prompt injection first. A browser agent reads text from pages it doesn't own — so a page can try to talk to it. That's the failure mode specific to this class of software, and it's where the adversarial suite starts.
Runnable proof over prose. Claims in a README are cheap; the test suite ships in the repo so anyone can run it against the deployment and see for themselves.
Limitations published by me, up front. One preset targets a source that blocks datacenter IP ranges outright. Rather than quietly dropping it, the agent detects it, names the cause correctly, and the constraint is documented in the repo. Surfacing your own limitation reads as engineering maturity; letting someone else find it reads as a gap you missed.
An engineering journal alongside the code — decisions, dead ends, and what changed my mind, written as I went.
Four and a half years of QA taught me the useful reflex here: the interesting bug is the one that looks like it worked. Twice during this build, “deployed” actually meant “stale cache” — which is exactly why the version marker exists.
Public and inspectable — the repo carries the limitations doc, the adversarial suite and the engineering journal.
Deep dive
Patchbay, every detail.
Tools like this are how non-technical people are starting to build with AI — drag boxes onto a canvas, wire them together, and a workflow runs. I wanted to build one properly, and the interesting problem isn't the dragging. It's that a real version of this has dozens of node types, and if every one is a hand-written component the thing collapses under its own weight. So I built the layer underneath: a way to describe a node as data, and have it become a working node on its own.
What it does PRODUCT
Drag a node out, wire the ports. Inputs, an LLM, filters, an HTTP request, free-text notes — drop them on the canvas and connect one to the next.
The text node is the clever one. Write {{ topic }} inside a prompt and a matching input port appears on the node, ready to wire — so a prompt template becomes a set of connections. It only accepts real variable names, and the box grows as you type.
Submit checks the wiring. Before a pipeline can run it's sent to the backend, which reports how many nodes and connections it has and whether the graph is valid — a pipeline that loops back on itself can never finish, so that's caught and explained in plain words.
~8 linesof a single object is all it takes to add a brand-new node type — no new component, no new file
The abstraction — the actual work ARCHITECTURE
A node is described as data, not code: its title, its fields, its ports, its colour, all in one small object.
A shared factory turns that object into a React component wired to the store, and a shared shell draws the card and lays out the ports. No node ever hand-places a connection point.
One registry is the single source of truth — it drives the node types, the toolbar and the styling together. Add one entry and the node appears everywhere at once.
Ports can be dynamic. The text node's inputs are a function of what you've typed, which is how {{ variables }} become live connection points without the framework knowing anything about templates.
Front end React + ReactFlow + Zustand; backend Python + FastAPI running a real graph check (Kahn's algorithm) that survives self-loops, duplicate edges and edges pointing at deleted nodes.
Designed as a product, not a demo DESIGN
For a tool aimed at non-technical people, the interface is the product — so it got a real design system, not a stylesheet.
A dark canvas tool in the register of Linear and n8n: every node accent, every border, every shadow is a design token, so recolouring the whole app is one file.
Nine hand-drawn SVG icons on a single grid and stroke weight, each taking its node's colour automatically — no icon fonts, no emoji.
The result reads as words first. Instead of a raw browser alert, a floating panel says “Pipeline looks valid” or “This pipeline has a cycle,” with the counts underneath and a colour that matches the outcome.
Motion with a purpose — nodes settle in when dropped, ports glow on hover, edges animate — all of it switched off for anyone who prefers reduced motion.
A full-stack build — React front end, hand-built design system, and a FastAPI backend that validates the graph before it runs.
Latest build — in full
Postmark, every detail.
Open any job-search tracker and ask where the "Applied" date comes from. A human typed it, from memory — and every metric downstream (time-to-response, median reply time) is built on that guess and quoted as fact. The employer sent a confirmation email the moment they received the application, carrying their timestamp. Postmark is built around the idea that the externally attested date is the only one worth computing on.
What it does PRODUCT
Receipts, not recollections. Employer confirmation emails become receipts with the employer's own timestamp — proof of delivery for every application, instead of a date typed in later.
An honest transition ledger. Every status change passes through one append-only ledger with a declared source — set-status, correction, backfill, manual — so a corrected date can never silently masquerade as an observed one.
Answer recall. BM25 search over everything already written in past applications, so the next form starts from your best previous answer rather than a blank box.
Live, stoppable runs. Long scans stream their output line by line (NDJSON) with a working Stop button — a three-minute job is watchable, not a spinner followed by a wall of text.
192automated tests on Node's built-in runner — no test framework, nothing to install
Built like it handles your mail — because it does ENGINEERING
Zero runtime dependencies. Node 20 and nothing else; npm install has nothing to install. No supply chain to audit, nothing to rot.
Local-first, by construction. Binds 127.0.0.1 only, reads your own files, sends nothing anywhere. The privacy claim is an architecture, not a policy page.
Sits beside career-ops, the 63k-star open-source job-search agent — Postmark picks up the employer-timestamp evidence that career-ops detects and then drops, one line before it becomes useful.
Tested at the seams: the ledger, the queue, the receipt parser, the tracker sync and the agent's Stop path each carry their own suite — 192 assertions, all green, verified on every release.
In build — the newest
Cue, every detail.
A real-time AI copilot for live calls: meetings, sales calls, interview practice. The category leader proved people want it. I'm building an independent version on my own code, infrastructure and models, and running it the way I'd want a team to run it.
The pipeline REAL-TIME
Audio in: mic, browser tab or system audio → 16-bit PCM chunks → voice-activity detection drops silence.
Streaming speech-to-text behind one provider interface, with failover inside a single utterance. The category leader's worst outage came from depending on one STT vendor.
Question detection → context engine → model gateway → answer streamed over SSE, all from the user's own résumé and documents.
Incremental by design: intent detection and context prefetch start on the partial transcript, so the answer is already warming up when the question ends. None of the five reference repos I studied does this.
Wave 0 — shipped in two days FOUNDATION
Monorepo: Turborepo + pnpm TypeScript, shared lint/tsconfig/Tailwind, CI gates, branch protection, CODEOWNERS and a PR template.
Realtime gateway: authenticated WebSocket with heartbeat, a session state store, and a published session-channel and launch-token contract.
Model gateway: provider adapters, our own model tiers (Flash / Swift / Core / Deep, never vendor names), a question router, and per-user budget, metering and pricing.
Plumbing: Zod env registry and secrets policy, Postgres 16 + pgvector and Redis 7 dev stack, palette-gated design tokens, privacy defaults, and a Prisma data model for Phase 1.
Run like a real team PROCESS
A Build Bible with a 15-phase roadmap, a numbered decision log, a competitive blueprint and a dashboard map, so no agent or teammate has to guess.
A squad-by-squad ticket backlog plus onboarding and kickoff prompts, so people and AI agents build in parallel.
One ticket = one branch = one PR, merged only on green CI. Anything the spec doesn't define is raised as a BLOCKER and never improvised.
The boundary is in the spec TRUST
Consent-first: a normal always-on-top overlay with standard OS permissions. Nothing that bypasses proctoring, monitoring or capture detection gets built, and "undetectable" is banned from UI, README and docs.
Privacy by default: audio is transcribed and then discarded, with retention TTLs and a deletion cascade. Provider keys stay server-side, and every STT-second and token is cost-logged per user.
Next: auth and accounts, streaming STT, then the browser vertical slice end to end. After that, native desktop capture on macOS and Windows.
Shipped first
I'm Okay, every detail.
The first product — designed and built alone in about six months, alongside the day job. In final build for Android and iOS: 40 languages, five tiers from ₹0 to ₹299. Demo access on request while store launch is finished.
What it does PRODUCT
Confirm you're okay on a schedule. Miss it, and your trusted contacts get told — through a plan-aware escalation pipeline (email on free, WhatsApp on paid).
No countdowns, no urgency cues, no tracking. The interface avoids alarm on purpose: the point is reassurance, not panic.
Shipped features: caregiver portal · meal, medicine & water tracking · weekly PDF report over WhatsApp · AI care assistant · Emergency SOS.
Engineering STACK
Node + Express API on Postgres holds all authority — the client never makes a safety decision on its own.
Next.js PWA + Capacitor wrappers for the stores, plus a separate, fully native Kotlin / Jetpack Compose Android app — built because Android throttles background work on a PWA, and the alarm has to fire anyway.
Redis locking, an orchestrator running 18+ background workers, and every alert delivered exactly once through a registry-first outbox.
Server time only — client clocks are never trusted.
I build with Claude Code as a pair-programmer — and I let the process be measured. Two independent tools have now done it: Y Combinator's Paxel analyzed a full month of my Elyxis build sessions, and Standout ranks me against other AI-native engineers. These numbers are observed, not self-reported.
0lines shipped in one month
0commits across 2 repos
0coding sessions analyzed
0 htotal build time
0 daysconsecutive shipping streak
0 hlongest single session
Full Stop & InvestigateEnforce Safety RailsDemand Production ParityScope Version BoundariesAudit Completeness
Paxel profiled me as an “architect-controller”: challenges premises, demands production parity, enforces hard safety gates — and converts AI output into bounded, verified engineering work. Speed is easy with AI; the discipline to keep it honest is the actual skill.
Decision focus: 123 of 152 recorded decisions were architectural — trust boundaries, data ownership, migrations.
Tooling: Claude Code in 143 of 147 sessions, running up to 3 agent instances concurrently.
Prompting: 863-word average prompt, ~8 prompts per session; 12% of code sessions open with an explicit plan.
Course control: only 6% mid-task redirects — briefs are written so agents rarely need steering mid-flight.
Domains that month: mobile auth · web settings · biomarker reporting · payment hardening · security passes · analytics · design sync · infra migrations.
What Paxel says I should fix — kept here on purpose, because the honesty brand includes me: tighter targeting on exploratory audits · the codebase grows faster than it simplifies (0.07 deletion ratio) · close the loop on outcomes (41 of 152 interventions had verified positive results at report time).
SOURCE: PAXEL BUILDER REPORT · YC · JUN 26 – JUL 26, 2026 · MEASURED, NOT SELF-REPORTED
0/100Standout score
#0of 156 on the founding-engineer leaderboard
0sessions measured
4.6Btokens directed
Standout independently profiles me as an “AI-Native Engineer.” Different tool, different month, same conclusion as Paxel — which is rather the point of letting someone else hold the measuring tape.
SOURCE: STANDOUT · standout-founding-eng LEADERBOARD · MEASURED, NOT SELF-REPORTED
The AI toolchain — 1.5 years of building only with AI STACK OF STACKS
Three agents, three jobs:Kiro (AWS) wrote the Elyxis specs — 37 requirements, 13 correctness properties · Antigravity (Google's agentic IDE) built I'm Okay end to end · Claude Code built the Elyxis rebuild — my daily driver, 143 of 147 sessions in the last measured month.
Models in the loop: Claude Opus 4.6 (thinking) · Google Gemini (Antigravity + I'm Okay's AI care assistant + ideation) · ChatGPT (ideation) · Veo (concept video). Design: Claude Design — 20 signed canvases and a capture→compare→fix fidelity loop; nothing merges until the built screen matches on-device.
My own machinery — 4 authored AI skills (~85 KB of codified process): a build-loop conductor/adjudicator (47 KB) · a self-evolving red-team engine (21 KB) · a five-phase ecosystem audit (17 KB) · a hard-gated session-discipline skill. Plus the Prompt Playbook (P0–P26 build loop), agent hooks that deny writes to secret paths, a post-commit security hook, a read-only design-reviewer subagent, agent memory, overnight batch runs, and swarm experiments (Ruflo architect/coder/reviewer topology) alongside the 35-skill gstack suite.
A second brain that feeds itself: an Obsidian LLM-maintained wiki (the Karpathy “Memex” pattern) — 40 entities, 74 concepts — filled by an automated capture pipeline: session-end hooks, an hourly sweeper, nightly AI ingest, secret redaction at intake, content-hash dedupe.
Security tooling: OWASP Top 10 2025 + OWASP LLM Top 10 as standards · gitleaks · bearer · a blocking pre-commit secret hook · six red-team passes carrying 46 tracked engagements.
Measured by: YC's Paxel and Standout — the telemetry above, from two independent tools. The discipline is the product.
For the past year and a half, every line I've shipped has had an AI agent in the loop. I'm not going back — I only want to work AI-native.
Open source 3 MERGED · 4 IN REVIEW
I read other people's code closely, find the bug nobody filed, and send a fix scoped so a maintainer can merge it. So far that's seven PRs across six projects, from a 72,000-star agent to a YC company's SDK.
+580 lines, including 402 lines of tests, reviewed by two maintainers and CodeRabbit. The formatter is lossy by design, so the PR asserts a fixed-point property (parse(format(x)) is stable after one pass) instead of a round-trip equality that would be false. The review added an opt-in strict mode that refuses unreadable input and names each bad line. Every fix is pinned by a mutation test.
The merge message on #2809 invited the wiring, so apply mode now recovers previous answers through a --read --strict CLI seam instead of re-reading prose. A new test section pins the contract.
In --attach text output, a CRLF log line left a bare \r behind and the next write overwrote the line. The fix trims \r\n and quotes embedded \r, matching JSON mode. It ships with 60 lines of tests.
An Obsidian plugin across 30 files. It does hybrid semantic + BM25 search over a vault, and Enter jumps to the matching section, not just the note. Chunking is heading-aware, with breadcrumbs and CommonMark-correct fences. The native runtime is isolated in a worker process so a native fault can't take down Obsidian.
The lookup trusted the first alias the API returned, so a query for my-image could act on my-image-arm64. The fix selects by exact alias match.
IN REVIEW
SigNoz docs #4242 · every app's telemetry was labelled as the collector
In the ECS-on-EC2 daemon guide, the detector read the collector's own task metadata. The fix moves ECS detection to the app's SDK and corrects two adjacent config errors.
tmate can't forward X11, so the PR documents the working route: Xvfb, then x11vnc on loopback, then noVNC. I also filed metorial #134, a CONTRIBUTING.md rewrite checked against the real repo.
LIVE STATUS ON GITHUB · AUTHOR: JCHAK7
The day job — in full
Amazon, every detail.
Quality engineering for Amazon apps, services and devices since Feb 2022. Before a release I write and run the coverage — manual passes and automated scripts; when something fails I reproduce it, find the actual cause, log it, and stay on it until it's fixed inside the team's SLAs. A good part of the job is automation: maintaining the pre-release suites, separating real defects from flaky tests, and building the scripts and tools that take repetitive work out of the day.
Hawkeye — agentic IP-infringement analyzer BUILT · AGENTIC AI
Takes one app identifier, pulls the full listing record (developer, title, description, artwork, package name, prior reviewer notes) from an internal catalog service behind SSO, and investigates whether the submitter actually owns or is licensed to distribute the app.
Checks: cross-store comparison, reverse-image provenance on every icon and promo asset, developer-identity and website triangulation, a keyword-and-title policy audit, and live trademark-register lookups (USPTO, WIPO Global Brand Database) matched to the app's marketplaces.
Returns an evidence-backed verdict (Likely Infringement / Rights Established / Inconclusive) with click-to-verify proof for every finding and a generated PDF. A specialist's 30–60 minute review now takes ~2.5–4 minutes.
Three engines, one policy playbook: Fast runs a parallel evidence graph with four concurrent LLM judges and a first-strike early exit. Deep Search is an autonomous browser agent (up to 320 plan-act-observe steps) that narrates each step and can be paused, steered or set to approve-each-step. Bulk runs up to 500 apps through a worker pool, escalating Fast to Deep automatically, with retries and resume after restart.
Stack: Python, FastAPI and asyncio driving Playwright; a React + TypeScript console with a live WebSocket feed; Claude Opus + Sonnet on Amazon Bedrock behind an adaptive throttle gate, prompt caching and truncation-aware retries. Deterministic verdict-integrity guards sit in code above the model output, backed by 100+ behavioral checks and a known-truth regression harness.
Pulse — live audit workspace BUILT · REPLACED EXCEL
Replaced the team's two regional weekly Excel workbooks for Policy, Functional and Feature app audits with a real-time web tool.
Admins upload each week's workbooks into region-tagged sheets and grant per-sheet, per-tester access. Testers work in a spreadsheet-grade editable grid: inline picklists, per-block assignment, Excel-style cell addresses and full cell-level history (who changed what, when, old → new).
Weeks can be locked, and every edit syncs live across concurrent editors over WebSockets. There's an admin dashboard, filters, cross-week history lookup and styled Excel export.
Stack: Python, FastAPI and SQLAlchemy (SQLite in dev, PostgreSQL in prod) with JWT auth and role-based access, and a React + TypeScript + Tailwind frontend. An importer brought in six months of history (~10,000 audit rows). It has 120+ automated tests and a Docker → AWS (ECR, App Runner, RDS) deployment kit.
Benchmarked 75+ top streaming apps on Fire TV against Apple TV, Google TV and Roku across five quarterly cycles — end-to-end: launch, Live TV, voice, universal search, sign-in, discoverability, IAP parity.
Logged 350+ customer-experience disparities, 60+ of them P0, tracked in JIRA with the platform team; fixes landed in-quarter.
Cycle by cycle: Q2 — 11 apps / 14 gaps · Q3 — 21 / 129 · Q4 — 11 / 94 · Apple TV Q3–Q4 — 10 / 87 · Q1'23 — 22 / 34. Took on Apple TV coverage on my own initiative when the team was short-handed.
Ran a back-button UX study across 20 P0 apps — worst offenders took 12 clicks to exit an app.
Live content quality ops DAILY OWNERSHIP
Owned daily quality for 300+ live news channels on Fire TV's news platform: blank screens, audio distortion, buffering, delivery failures — escalated same-day, inside SLA.
Enforced content-freshness thresholds (e.g. three uploads per four-day window per channel), chasing providers on misses and tuning trailing configs to kill false-positive tickets.
Added ad-load validation: whether ads load, how long they run, how many appear per video — balancing user experience against revenue compliance.
Audits & the quality bar CoE
Audited 200+ app policy decisions as part of the audit function, catching 50+ tester mismatches and coaching peers on the patterns behind them.
Sustained personal quality at or above 100% of the team benchmark for consecutive months; multiple Spot Awards and Jedi Ranger Awards.
Platform integrity FRAUD
Spotted a paid-app scam pattern among YouTube channel-creator apps — developers monetizing free content — which triggered verification of every paid channel-creator app in the catalog.
Contributed to the team's enforcement waves that removed thousands of fraudulent vendor accounts and non-compliant apps, including illegal IPTV streaming apps.
Catalog & developer experience SELECTION
Devised an APK pre-testing mechanism and SOP to validate Play-Store apps' Fire TV compatibility before onboarding — feeding a multi-million-dollar catalog selection program and closing the gap with third-party app stores.
Resolved 100+ third-party developer support cases end-to-end in Amazon's partner CRM.
Automation & enablement TOOLING
Part of the team's automation initiative: Maestro UI suites across the top-40 catalog apps, an automated results pipeline covering 500+ apps (~85% manual effort cut), review processing brought from 10–15 minutes to 6.3 seconds, and SDK compatibility analysis across the top-200 list.
Built 7+ operational SOPs (including their HTML backends), the team newsletter, and the training visuals that cut decision mismatches across the team.
Functional, policy and compliance testing across Amazon's app ecosystem — Appstore, Fire TV and tablets.
Designed and built Hawkeye, an agentic-AI IP-infringement analyzer (Claude on Bedrock, Playwright browser agent) that cuts a 30–60 minute review to ~3 minutes, and Pulse, a real-time audit workspace that replaced the team's weekly Excel workbooks.
Competitive parity benchmarking of top streaming apps against Apple TV, Google TV and Roku — 350+ experience gaps logged and triaged with platform teams over five quarterly cycles.
Daily quality ownership of 300+ live streaming channels: playback health, ingestion SLAs, content-freshness validation.
Policy audits and tester coaching, third-party developer support, and contributions to the team's UI-automation initiative.
Sustained 100% quality scores; multiple Spot and “Jedi Ranger” awards.
Founder & CEOLeadShala Digital MediaAUG 2020 — PRESENT
MSME-registered in India as a sole proprietorship. Performance marketing on retainer, backed by a 30-day money-back guarantee — and every function done myself: a ten-question niche filter I wrote, finding owners on Instagram, closing on Zoom, building the landing pages, running the Meta and Google ads. Niches: home services, wedding planning, senior care, furniture retail — across India, the US, the UK and Australia. Since 2026, the company behind I'm Okay and Elyxis.
Campus AmbassadorIIM Bangalore · Vista '21JUN — AUG 2021
Promoted India's biggest business summit; selected from a national applicant pool.
Supabase · Postgres + RLSRailwayFastAPI + statsmodelsDeno edge functionsReact Native + Expo/EASCapacitorJetpack Compose · Room · WorkManagerHealth ConnectRedisPaddle · Stripe · Razorpay · Apple IAPWhatsApp Business APIWebSockets · live streamingPlaywright · headless ChromiumSentry · PostHogGit / GitHubGoogle Ads · Meta AdsProgrammatic SEO
What clients said
On working with me.
Not many people can handle market trade-offs as Jay can. He was always very patient, solution-oriented and there was nothing he couldn't solve. He is also very kind and easy to deal with.
Eric Kremer · Client, De Kap (Netherlands) · via LinkedIn
That was an amazing experience! Awesome communication, very knowledgeable, and super talented! I would definitely highly recommend him.
Zahmoul El Mays · Client, Attorney at Law · via LinkedIn
🤝 Volunteer, Robin Hood Army — since 2016📣 28,000+ LinkedIn followers🌏 Open to global opportunities
Contact
Let's build something honest.
I fit anywhere in engineering: backend, full-stack, mobile, QA & test automation, tooling. Open to remote work anywhere; willing to relocate — US (needs visa sponsorship), UK, Dubai / UAE, Australia, New Zealand, Canada, or Delhi. One non-negotiable: I build AI-native. For the past 1.5 years every line I've shipped has had AI agents in the loop, and I'm looking for teams that work the same way. What stays the same wherever I land: tests green before merge, claims the product can back, and things that actually ship.
I work at Amazon by day; nights and weekends I built six products end to end, solo, with Claude Code as my pair-programmer. I am the evidence for my own thesis: one person with modern AI tooling can build what used to take a team.
