Product.ai
Max Arias, Frontend Fortress Lead at Product.ai
Frontend Fortress Lead

Max Arias

Frontend Fortress Lead · Product.ai

The frontend lead across every Product.ai and SimplyCodes consumer surface (SimplyCodes is Product.ai’s consumer coupon-and-deals product): the browser extension, the web apps, the blog, and recruiting intake. If a user touches it, he owns the front of it.

A multi-surface frontend specialist who ships fast, reliable, polished UI, working async-first. Defects don’t wait — when QA flags a real bug, the fix ships the same session.

Tenure
Founding era
Stack
Svelte · Astro · TypeScript · Cloudflare Workers
Owns
Extension · Web · Blog · Recruiting
Based
Buenos Aires, Argentina
6
Consumer surfaces owned end-to-end on the frontend
4
Browser targets kept stable — Chrome, Firefox, Edge, Safari
160+
Blog articles migrated to a faster static pipeline
48hr
Citation tooling shipped to production from spec
About

Frontend lead who owns the user-facing half of every Product.ai and SimplyCodes surface — extension, web, blog, and recruiting intake.

6
frontend surfaces owned
4
browsers kept stable
48hr
spec → production
160+
articles migrated
The range

01 · Core surface

Browser Extension

The SimplyCodes extension across Chrome, Firefox, Edge, and Safari — capture reliability, conditions UI, and merchant-aware behavior. Released a major version to every store in one day.

02 · Core surface

Web — Product.ai

Built on Cloudflare Workers and Astro. The brand relaunch, the research hub, citation tooling, and the rebuilt chat experience all shipped on this stack.

03 · Core surface

Blog & Discoverability

The SimplyCodes blog moved to a fast static pipeline with structured data for machine-readability and isolated per-change previews. 160+ articles migrated.

04 · Core surface

Recruiting Site

Built and shipped the recruiting site end to end, then the candidate application intake form — including a same-day fix that closed a link-validation flaw before it reached production.

05 · Off the obvious map

Data-Capture Reliability

Owns the frontend side of the data-capture layer: checkout detection, zone selection, capture quality — so the verification engine operates on trustworthy evidence.

06 · Off the obvious map

Serving Infrastructure

Prototyped a faster retrieval path for the knowledge-serving layer. Active necessity, not a side hobby — he goes where the surface needs him.

What he ships

One discipline, the whole consumer perimeter — six surfaces in two months, each a different stack.

2025 → Now · Product.ai
Product.ai
Frontend Fortress Lead
Owns the frontend across the full consumer perimeter — the SimplyCodes extension (kept stable on four browsers), Product.ai and SimplyCodes web, the blog migration to a fast static pipeline, and recruiting intake. Led the website brand relaunch from the old company name, built citation tooling end-to-end in 48 hours, and carried the rebuilt chat experience to ship ahead of its target. The recurring pattern: when QA surfaces a real defect, the fix ships the same session — including a same-day security catch on a link-validation flaw that could have accepted a spoofed domain. Also owns the frontend reliability of the data-capture layer so the verification engine runs on real evidence.
The whole consumer perimeter
Before Product.ai
Before · Frontend engineering
Frontend engineering
Frontend specialist
A multi-stack frontend engineer before Product.ai — Svelte, Astro, TypeScript, and Cloudflare Workers. The breadth that now lets one operator own a whole consumer perimeter instead of a single app.
Multi-stack foundation
Operating code

Six principles that show up across how he ships.

01 Identity

Be the person who finished it.

Performance and polish — the small details a user never consciously notices but feels. Loading states, micro-interactions, the edge cases on a bad connection. The difference between a surface that was finished and one that wasn’t.

“I want to be the person who finished it.”

02 Method

Pre-flight the spec before touching code.

When a spec has gaps he’d hit mid-build, he surfaces them to the author first. The spec sharpens, then he ships — execution that improves the spec, not just satisfies it.

“I focus on frontend execution, and I sharpen the spec before I build.”

03 Tempo

Defects don’t sit.

When QA flags a real bug, he diagnoses and ships the fix the same session. A missing structured-data tag, a link-validation flaw that would have accepted a spoofed domain — found and closed same-day, not queued for next sprint.

“When QA surfaces a real defect, the fix ships the same session.”

04 Mode

Collaborate upfront, then go heads-down.

Understand the requirements fully, then work solo and focused. Several parallel build sessions across surfaces, no collisions. Mornings are the best hours for deep work.

“Async-first. I’d rather leave a decision in a pull-request description or a thread — it’s easier to look back on.”

05 AI posture

Let the AI write code — never let it push.

Reads and validates every change before it’s committed. The model is a co-author, not an autonomous shipper. Written records are the durable trail, so the next session (human or AI) picks up the context.

“I let the AI do the coding, but I don’t let it push. I read and validate every change.”

06 Direction

From frontend-as-non-bottleneck to frontend-as-first-ship.

The arc is moving from steady-state maintenance toward greenfield consumer surfaces — where the user experience is the open question. Every new surface ships frontend-first, not frontend-catching-up.

“More time on new consumer surfaces — greenfield builds where the experience is the question. More first-ship moments.”

Scope

What he owns. What he intentionally does not.

The anti-goals are part of the design — they’re why the frontend stays load-bearing instead of sprawling into spec authorship and design direction.

Owns — accountable

The full consumer-facing frontend perimeter.

The SimplyCodes extension across four browsers · Product.ai and SimplyCodes web · the blog and its static pipeline · recruiting intake · and the frontend reliability of the data-capture layer so the verification engine has trustworthy evidence. Plus machine-readable structured data on every surface he ships.

Does not own — by design

The lines that keep the role sharp.

Backend and platform architecture, serving infrastructure, and the data backend live with other owners. He doesn’t originate product specs or design direction — he sharpens specs and executes them. And he never pushes AI-generated code unreviewed. The anti-goals are the architecture.

What sets him apart

Six surfaces, each on a different stack, one operator.

Six surfaces, one operator

He owns six: the browser extension across four engines, the web apps, the blog and its migration, the recruiting site, data-capture reliability, and the serving layer behind it. The whole consumer perimeter, not a slice of it.

The pre-flight discipline

Surfaces spec gaps to the author before writing code, so the spec improves on the way to shipping. Execution that sharpens the spec, not just satisfies it.

Same-session defect triage

A missing structured-data tag fixed in twenty minutes. A link-validation flaw that would have accepted a spoofed domain, closed across two endpoints in one session. Defects don’t sit through a sprint.

Frontend reliability for upstream sensing

Owns the frontend quality of the data-capture layer on the commerce surfaces: checkout detection and zone selection, so the verification engine operates on trustworthy evidence.

Multi-stack polyglot inside a “frontend” title

Ships Svelte, Astro, TypeScript, and Cloudflare Workers, and moves into the serving layer when the surface needs it. The “frontend” title is the floor, not the ceiling.

Speed with stability

Fast shipping that doesn’t crash — a major extension release to every store in one day, citation tooling in 48 hours, the chat rebuild ahead of target. The reason frontend isn’t the bottleneck.

Product.ai’s public surfaces (the website, the extension, the research hub, the blog) are the shipped record of this work. See the code →
The through-line

Identify the surface, sharpen the spec, ship the frontend end-to-end, then polish until users don’t notice — because nothing is broken. He’s the reason frontend isn’t the bottleneck.

Product.ai builds with operators like Max — engineers who own a whole surface, not a slice of one. See open roles →