The Lumate Arc: From Student App Studio to Adtech Venture
A public overview of how Lumate grew out of student projects, became a high-scale mobile advertising platform, hit structural limits, and reshaped what came next.
Overview
As co-founder, led a 10-engineer team to build a demand-side and supply-side platform that operated as a real-time market-maker in programmatic advertising — buying and selling digital ad impressions in under 300 milliseconds, billions of times per day. The system spanned Django, AWS, Docker, Redshift, Kinesis, Redis, and a custom ML pipeline for bid pricing.
Context
AdTrade grew out of a concrete observation, not a pitch deck. Our mobile apps and games — especially Memory Matches — showed that ad performance changed materially when the app had better contextual and audience information. The opportunity stopped looking like “build more apps” and started looking like “build the infrastructure that makes ad inventory smarter and more valuable.”
That thesis became Lumate’s core platform. AdTrade sat in the middle of the programmatic advertising market as a market-maker: buying mobile ad inventory from one side, enriching and pricing it with additional data, and reselling it into the other side — with the entire evaluate-price-trade decision completing in under 300 milliseconds, billions of times per day.
I co-founded the company and led the 10-engineer team, spanning St. Louis and Rolla, that built and operated it.
The System
A trading-layer approach to advertising has the same core requirements as a trading-layer approach to anything: extreme throughput, strict latency, and pricing logic that learns faster than the market moves.
- The trading core evaluated and traded inventory in milliseconds, built on AWS with OpenResty, Docker, ECS, and Django services around it.
- A continuously-learning pricing pipeline — built before TensorFlow existed — ingested auction outcomes, recalculated SQL-based pricing models, and deployed updated parameters automatically. Pricing was never a static rate card; it was a feedback loop.
- A 54-node, 1TB in-memory Redis cluster fronted by Twemproxy buffered real-time bidding data, sustaining extremely high concurrent reads and writes at sub-millisecond latency.
- Stream and warehouse layers on Kinesis and Redshift carried the event firehose into analytics, so pricing research and business reporting ran on the same data the trading core produced.
By 2015 the platform was serving millions of ads per day and hitting major throughput milestones, with real pricing advantages from data-enriched inventory.
Outcomes
- A functioning real-time market-maker in mobile advertising, operating at billions of decisions per day with meaningful commercial traction, backed along the way by Arch Grants, Capital Innovators, and Missouri Technology Corporation.
- Durable technical capability: the distributed-systems, cloud-architecture, and machine-driven-decisioning patterns built here carried directly into later data ventures, including Great Data Lake.
- The venture itself ultimately failed — a receivables shock hit a demanding capital structure at the wrong moment. I tell that part of the story plainly in The Lumate Arc, because the venture-design lessons are as much a part of the proof as the technology.
Artifacts
This is the actual system diagram from the 2013 investor deck — the market-maker structure described above, drawn the way we pitched it at the time:
Anyone can write a glowing case study about their own company. That is why this section exists: the claims above should be checkable on surfaces I do not control.
- Lumate’s profile at Arch Grants — part of the first Arch Grants class in 2012; lists the AdTrade™ and AdMotive™ products and names me as President.
- EQ Magazine’s Lumate profile — St. Louis startup-ecosystem coverage from the operating era.
- EQ on the first Arch Grants cohort — names the partners and the company’s origin in mobile games.
The origin is visible too: the IDC Projects story includes the studio’s 2012 demo reel — the games whose ad data seeded the AdTrade thesis.
Patterns Worth Reusing
- Find the thesis inside the operating data. The pivot from apps to infrastructure came from noticing what our own revenue data was saying, not from market research.
- Build the feedback loop, not the model. The pre-TensorFlow ML pipeline worked because it automated the full cycle — outcomes in, parameters out — rather than perfecting any single model.
- Infrastructure is the moat in a market-maker. The Redis buffer and stream architecture were what let pricing intelligence act at market speed; the edge lived in the plumbing.
- Technical strength does not exempt you from capital structure. The system worked. The financing structure around it is what broke — which is why venture design is now a first-class part of how I build.