The RFP arrived on a Thursday at 4:47 in the afternoon, forty minutes before the office emptied into a long holiday weekend. A good opportunity. Clean census, motivated employer, a renewal ugly enough to move. It landed in the inbox of a capable, experienced professional who had already shut her laptop, because she is a human being, and human beings shut their laptops.
By the time she opened the email Tuesday morning, noticed the census was missing dependent data, emailed the broker, waited for the corrected file, and prepared the submission, it was Thursday again. A full week, and the RFP had not reached a single carrier. The same employer had sent the same information to a second broker, whose general agent happened to check email over the weekend. That quote arrived first. That broker became the hero. The business was gone before anyone on our side did anything wrong.
That is the detail worth sitting with. Nobody made a mistake. The system performed exactly as designed, and the design lost. This is a composite from my two decades in this industry, but barely.
I wrote in a previous piece that the RFP is dead. This is the story of what I built to replace the part of it that was already a corpse.
The Circadian Problem
Human-driven workflows do not fail because humans are bad at the work. They fail because humans operate on schedules. We sleep. We take Fridays off before long weekends. Our kids get sick. These are not character flaws; they are the operating conditions of being a person, and every one is a window during which a competitor’s submission is moving and yours is not.
For most of this industry’s history, that did not matter, because everyone’s windows were roughly the same. Knowledge was the moat, and speed was a rounding error. Artificial intelligence is leveling the knowledge advantage faster than most practitioners want to admit, and what remains when knowledge is evenly distributed is raw processing speed. Not speed as a virtue. Speed as the last variable still in play.
So the question I set out to answer was narrow and unglamorous: how many of those windows can be shortened, and how many can be eliminated entirely?
What We Actually Built
RFP intake in a general agency runs through email, and that is not changing soon, so the build starts inside the mailbox itself. The first architectural decision: meet the workflow where it already lives instead of asking anyone to adopt a new portal.
The system monitors the intake mailbox continuously through Microsoft’s programmatic access layer. When a submission arrives, it is opened, parsed, and evaluated against a defined sending threshold within moments. Does the census contain the required fields, and if not, which are missing? Is the invoice for this group, and do its lines match what is being quoted? Which market is this, and which carrier contacts receive it? Each check is its own small, testable component. Most are pure code: deterministic logic that validates structure, cross-references documents, and fills gaps from an internal data repository. A language model sits over the top and handles only what code cannot: the ambiguous document, the census formatted seventeen creative ways.
During testing the pipeline averaged nineteen RFPs a day. The human baseline was respectable: eleven minutes on average to respond to a broker during working hours, and one hour and twenty-seven minutes to get a clean RFP out to market. But averages are where this industry hides. The eleven-minute figure describes a Tuesday at ten in the morning, not the Thursday at 4:47 or the holiday weekend. The averages were respectable. The tails were fatal.
After automation, the broker receives acknowledgment and a full review summary in under one minute. A clean RFP is scrubbed, built, and delivered to carriers in under two. Stress-tested with twenty simultaneous submissions, more than a full day’s volume at once, every acknowledgment cleared in just over two minutes and every RFP was fully built and submitted in three minutes and thirty-one seconds. A human works sequentially. The system has no queue a person would recognize, and the Thursday before the long weekend no longer exists as a concept.
Everything Broke
The paragraph above is the survivor of a process that failed constantly. Things broke every day. A submission would enter the pipeline and simply die, a dead hang with no error and no explanation. I would edit the code, test again, watch it hang again, with no idea why. Eventually I built a separate tool whose only job was to watch the automation work in real time, so I could see exactly where it stopped breathing.
What the monitoring revealed was humbling. My deterministic logic kept collapsing on inputs I had dismissed as edge cases, because I had the frame backwards. Human behavior is made up entirely of edge cases. There is no main case. Even inside a heavily regulated industry, the variability of human speech and behavior cannot be enumerated in advance from one person’s assumptions.
The fix was not to surrender the work to the model. It was to make the code more literate: an almost litigious branching of if-then logic, encompassing every manner and variation of request we had actually encountered. I pushed 1,183 historical RFPs through the pipeline, every failure teaching the code a new branch, until it could handle everything the record had ever thrown at a human. The corpus taught the code. It is as close to complete as that record allows, and the monitoring tool catches whatever the record missed.
Why Hard Code First
The instinct, among people who interact with AI only topically, is to route everything through the model. Upload it to AI. Let the AI do it. The build taught me this is exactly backwards. A model call is probabilistic, comparatively slow, and costs money every time it runs. Deterministic code is instant, free after it is written, and produces the same answer every single time, which matters enormously when the answer is “this invoice does not match this group.” The discipline becomes: use the AI to help write, proof, and expand the code, let the code carry every load it can, and reserve the model for the genuinely ambiguous residue.
There is a real irony here. The better the AI gets at helping you build, the less the finished system depends on AI. Every component that graduates from model call to hard code makes the pipeline faster, cheaper, and more reliable. The model’s highest use was never doing the work. It was augmenting the knowledge base of the person designing the work. That distinction, between AI as laborer and AI as leverage, is the entire ballgame. The pipeline works because it was designed from first principles by someone who has processed these submissions by hand. The knowledge came first. The automation is that knowledge, expressed in a form that does not sleep.
Where the Humans Stay
The system was also designed around hard boundaries. Even when a submission is perfectly clean, the broker receives a copy of what was produced and is asked to review it for accuracy. Internally, finished RFPs are saved to drafts for human review before distribution. The system can send without that check, but at this nascent stage, human validation is how you capture the edge cases the historical corpus never contained.
The subtler guardrail is something I call anticipatory outcomes: conditions that do not stop an RFP but that experience says will become a problem later. A group sits ninety-one days from renewal; the carrier requires the renewal document once it is inside ninety. The submission can go out today, but the system knows what will be asked tomorrow, flags it, and a human decides how to get ahead of it. That is not automation replacing judgment. That is automation scheduling judgment’s arrival.
Because judgment, at the end of the day, is still human, and so is selling. Code is a bad tool, at least for now, for convincing someone to buy something, or for navigating decisions that are emotional rather than logical. The system compresses the checking, the matching, the routing, the waiting, the parts that were never judgment at all, so the human layer gets the time it deserves. Speed is the magnitude of a change in position over time, and the discipline is knowing where to apply it. The week an RFP used to spend dying in an inbox was not deliberation. It was friction wearing deliberation’s clothes.
The Practitioner’s Turn
The loudest voices on AI in this industry belong to watchers: people with predictions, panels, and opinions about what the technology will eventually do to the business. I have been one of them; the first three pieces in this publication are watching with above-average seat locations.
This piece is different, and the difference is the point. The distance between understanding what AI will do to your industry and building something that does it is enormous, and it is exactly the distance the watchers hope nobody measures. The system described here was not built by a software company or a consultant. It was built inside the workflow, by a practitioner, one broken component at a time, and it is running right now, tonight, while everyone it competes against is asleep.
The industry does not need more forecasts. It needs more people willing to open the hood. The overnight part was never a metaphor.