Michel Grolet

Controlled publisher platform migration

A large mobile-gaming publisher wanted to move ad-monetization platforms and could not put its revenue base at risk to find out whether the move was right.

What I did

• Led the migration end to end, alone, on shared team tooling.
• Diagnosed the live stack from publisher logs, application testing, stack review and interviews with their technical stakeholders.
• Designed a hybrid mediation architecture keeping the other demand sources as bidders rather than cutting them.
• Wrote the analysis in BigQuery SQL and the parameterized dashboards that watched the trial.
• Ran both platforms at once on evenly split user groups, randomized with Firebase A/B Testing, instead of comparing before and after, and verified the split was balanced in BigQuery.

The publisher migrated fully: +28% revenue, +30% average CPM, +25% fill rate. The monitoring and the comparison tooling were reusable.

The publisher's own engineers integrated the SDK. I did not write the randomization code.

Agentic application-audit pipeline

Auditing how an app is monetized meant reading static ad logs by hand, one app at a time. A Google AI research team had built an agent that could navigate an app on its own.

What I did

• Shipped the product and the pipeline around that agent: a crawl-request interface, one-off and scheduled jobs, application-context input.
• Added APK and SDK-version comparison so two builds of the same app could be diffed.
• Wired a job runner to an internal device test fleet so audits run across device types.
• Shipped a context-aware reporting dashboard and an export path for deeper analysis.

Audits that were manual and per-app became scheduled and portfolio-wide.

The navigation agent was built by a Google research team; I own the product and pipeline around it.

A context system for client work

Agents working across many parallel client workstreams kept reading context that had gone stale.

What I did

• Designed a per-client folder and skill structure, with git-versioned markdown as the source of truth.
• Ran a worker that refreshes it hourly and on every new email, and reconciles uncertain updates through chat.
• Set the update rules: trust direct meeting notes and customer email, apply automatically only when nothing contradicts an established fact, and hold anything touching money, configuration or a live setting for human review.
• Chose no RAG. The agent reads plain markdown, because freshness and auditability mattered more than semantic retrieval.

It decompiled a new customer's APK overnight and surfaced main-thread work, wrong banner refresh rates on specific networks, and an ad-request volume carrying latency and policy risk. The customer reviewed the guidance and moved to a safer approach that kept the revenue.

The underlying agentic platform and the compute are Google's.

Portfolio-wide opportunity detection

An agent reading serving code surfaced a rule tying ad-slot size to video demand that appeared nowhere in the written documentation.

What I did

• Applied the change on one customer first and saw the extra video demand in the logs.
• Wrote the detection logic in SQL over the serving data, and the portfolio-wide dashboard on top of it.
• Took the query to engineering for review before any scale-out; they measured the average uplift independently.

The recommendation went out across a broad publisher base and Product shipped it into the publisher product.

The dashboard sized an opportunity. It was a prioritization signal, an upper bound, never booked revenue.

Classifier inspection tooling

Engineers building YouTube classifiers could not see what their models said about a video, a channel or a playlist without leaving the surface they were looking at.

What I did

• Wrote the tool from scratch to production in TypeScript: the interface, its backend endpoints, and support for videos, channels and playlists.
• Wrote a shared annotation library used across four YouTube surfaces, so a new classifier onboards by configuration alone.
• Shipped it through a verified-build release path; after I escalated an issue there, the platform security team corrected the central documentation.

It replaced the previous version and settled at a few hundred weekly active users.

Built against a mock API: apprentices could not access user data.

GPU rendering in a medical image viewer

A web 3D viewer for radiological studies was CPU-bound and lagged.

What I did

• Traced the bottleneck to the inherited rendering path and moved rendering to the GPU through WebGL.
• Added client-side caching and progressive image streaming.
• Handled an upstream library that shipped a TypeScript-only rewrite mid-project: contacted the maintainers, helped reverse-engineer and compile the unreleased packages internally, and kept the team unblocked.

More than 10x the frame rate.

Rebuilding a sports marketplace

The product had shipped with security problems, an inconsistent architecture, weak specifications and infrastructure that did not fit the business. I audited it and argued for a rebuild rather than a patch.

What I did

• Rewrote the product scope with domain specialists before any code.
• Recruited seven people across backend, frontend, mobile, security, infrastructure, design and product.
• Set product direction, priorities, architecture and team process, and owned roadmap, risk, resourcing and the CEO relationship.
• Chose the stack: Laravel, React, Flutter, GCP — GKE then Cloud Run, Cloud SQL, CI/CD, Terraform.
• Wrote the demos used to pitch venues and partners, and generalized from one customer's workflow rather than designing for everyone at once.

A working two-sided product — web, iOS, Android and a venue back office — with the first real customers live. I stepped back to advisor and kept equity.

The engineers I recruited wrote the production application code. What is mine here is architecture, product, hiring and leadership.

RAG prototype for construction compliance

A cofounder had the idea and a first demo. I joined to make the implementation real. Prospective clients would not send construction documents, contracts and plans to a hosted service, so it had to be self-hostable.

What I did

• Made self-hosting the deployment target, with multiple projects and role-based access.
• Implemented dynamic ingestion: upload and removal, OCR for document text, image description alongside OCR with a pointer back to the original image.
• Implemented chunking, embeddings and cosine retrieval, with answers citing their source documents and images.
• Started automatic detection of discrepancies and compliance gaps across a project's documents.

A prototype. No production users. It stopped for lack of traction and lack of time on both sides.