Rohit Kelapure · Cofounder. Product Manager and first FDE @ 8090 · Palo Alto

Fax is still an API. COBOL still prices claims. I work where the official process stops explaining itself.

I sit with the people who know the exception paths, turn that into product intent agents can execute, and keep humans on the decisions that create liability.

Cofounder. Product Manager and first FDE @ 8090. Since 2003: IBM runtimes → Pivotal modernization → Google Cloud GTM → applied AI in production.

The last mile is the whole problem

Enterprise AI doesn't fail because the model can't write another paragraph. It fails because the official process is not the real process.

The real process includes the fax that arrives sideways. The claim rule buried in a transmittal nobody indexed. The medical reviewer who knows exactly which sentence will trigger another review cycle. The salesperson who can configure a custom pack only because she remembers what the old system leaves out.

Interviews produce requirements. Watching people work produces the exception paths. The software has to survive both. That's why I work on-site before I write a line of intent.

"Fax is still an API in healthcare."

The arc

IBM2003–2014

Eleven years inside a runtime: caching, contention, deadlocks, memory pressure, production Java at scale. Built WebSphere caching infrastructure for Fortune 100s. Set SPECjEnterprise world records. Wrote 300K+ lines that shipped to production.

19 patent filings, including 10 grants. Two Outstanding Technical Achievement Awards.

Pivotal2014–2020

Modernization is not a code problem. Architecture, team structure, language, incentives, delivery practice — they move together or they don't move. Helped build the app-modernization practice from zero to $250M ARR. Led 50+ solution architects.

Wall Street Journal coverage. 50K+ developers trained.

Google Cloud2020–2024

Good technology doesn't distribute itself. Led specialist and GTM work across modern apps, databases, early Gemini. Built a team of 10 senior specialists. Managed 300+ opportunities in 2023. Hit 162% of pipeline target.

$250M+ revenue. Grew Application Transformation business 10x.

80902024–present

All the threads collapsed into one job. Sit with the customer. Shape the product. Build the system. Measure the failure. Explain the economics. Carry what we learn into the next version of the factory. Healthcare and life sciences — where the stakes are real.

8+ production enterprise projects. PRD-to-production in 3–6 months.

Field notes

When the input is a five-figure weekly fax stream

At a national healthcare-equipment provider, we built document-intelligence and audit workflows around a large weekly fax stream. The production system combines document models, workflow rules, patient matching, and escalation — not one model pretending it can solve every page.

The demo reads documents. Production reads documents that arrive sideways, half-cut, or with someone's coffee ring obscuring the patient ID. Confidence thresholds and fallback chains matter more than the model.

Discovery, production system design, healthcare domain

When a quality score refuses to flatter you

For a specialty-pharma medical-affairs workflow, we built a six-stage, human-controlled document pipeline with auditability and formal evaluation. Authoring time dropped from hours to under two. The composite quality score moved from a weak baseline toward a harder target — I prefer publishing the unfinished number.

In regulated work, the review gate is the product. Skip it and you don't have a product — you have a liability.

Regulated AI systems, evaluation design, life sciences domain

When the business rules live in COBOL

We're reverse-engineering Medicare pricing applications before attempting a COBOL-to-Java modernization. The first deliverable is not replacement code. It's a defensible map of business rules, dependencies, inputs, outputs, and exceptions.

You don't rewrite the code until you understand the code. There is no silver bullet here — you reverse-engineer the rules first or you ship bugs at scale.

Legacy modernization, code understanding, government systems

When discovery takes a month, not a prompt

For a custom surgical-pack business, discovery ran for weeks across manufacturing, commercial operations, and IT. The PRD went through multiple versions before steering-team acceptance.

An agent cannot rescue you from an ambiguous product. It will implement the ambiguity faster and with more confidence. That's worse.

Product discovery, cross-functional alignment, enterprise software

What production changed my mind about

01

An agent will implement ambiguity at machine speed

Better models make unclear requirements more expensive, not less. They produce more convincing wrong work, faster. Intent, examples, exclusions, and acceptance tests are now runtime inputs — not things you figure out later.

Healthcare AI taught me this — a confident wrong answer creates audit liability.

02

The PRD is becoming executable source code

A PRD is not done because a room of humans nods at it. It's done when it's precise enough for agents to decompose, build, and test — and for an independent judge to reject the result when it misses the intent.

Watched agents faithfully build the wrong thing from ambiguous specs. More than once.

03

The unautomated 10% is architecture

"Ninety percent automated" tells me nothing. What happens in the other ten percent? Who sees uncertainty? Who can override the system? What evidence do they get? What gets recorded? That's the architecture.

Built escalation paths for document-intelligence systems. The 10% is where the product lives.

04

Every backlog now has a token budget

Agent labor is not free just because it's fast. Model choice, reasoning effort, retries, review depth, context size — these are scheduling decisions now. Cost per accepted outcome matters more than tokens burned or lines generated.

Managing agent fleets at 8090 where inference cost is a P&L line.

05

A second model is cheaper than a confident mistake

I run adversarial review on plans, PRDs, architecture, and business-case math. Two models disagreeing is information. Two models agreeing is not validation — it might just be two models confidently wrong.

Shipped regulated content where a single error triggers full re-review. Prevention beats rework.

06

Problems belong before wins

My status updates lead with the risk. Customers can handle bad news. What they can't handle is discovering the team edited reality to keep a slide green.

Google Cloud, 300+ opportunities. Surprises killed more deals than bad news ever did.

07

If nobody can trace why the code exists, speed is a bug

Requirements link to designs. Designs link to work orders. Work orders link to code and validation. Break that chain and agents turn every upstream misunderstanding into technical debt at machine speed.

Built traceability into 8090's software factory. Without it, you're just generating debt faster.

The system

A software factory is not six coding agents

I run multiple Claude Code and Codex agents on one repo. Useful. But that's not the factory.

The factory is the system around them:

  • Intent— problem, constraints, exclusions, measurable outcome
  • Design— architecture and decisions agents may not silently rewrite
  • Work— bounded orders with dependencies, permissions, checkpoints
  • Assembly— code generated inside a controlled repo and deployment loop
  • Validation— tests, evals, adversarial review, human decision rights
  • Traceability— an unbroken answer to "why does this code exist?"

The maturity ladder is not autocomplete → more autocomplete. It's human inside every loop → human managing loops → agents operating within policy → humans accountable for the system.

Stop being the thing inside the loop. But don't remove responsibility from the loop.

Looking ahead

The next decade

Software organizations are about to manage machine labor. That changes everything.

Teams will schedule model strength, reasoning effort, context, retries, and review — same way earlier generations scheduled compute. Product leaders will write intent for humans and agents. Engineering managers will own agent queues and acceptance economics. Audit trails will become organizational memory you can actually query.

The durable companies won't be the ones generating the most code. They'll be the ones that turn institutional judgment into software — and keep a named human on the hook when the call matters.

Field notes from the software factory

Writing

The AI autonomy spectrum of software development →Stop being the thing inside the loop →Writing PRDs that autonomous agents can actually use →Can AI agents build from your PRD? →Do you know the token cost of your backlog? →From prompts to harnesses →

Book: Pragmatic Microservices — a practical guide to building microservices at scale.

Speaking: SpringOne Platform, JavaOne, IBM Impact, No Fluff Just Stuff, ÜberConf

Archive: Application Modernization, Cloud Architecture, Performance & Caching

LinkedInkelapure@gmail.comGitHubBlog