Discover how Serval's AI-native platform transforms IT operations by automating help desk requests and building intelligent workflows. Learn from Serval CEO ...
Building AI-Native IT Platforms: Lessons from Verkada and Serval's Path to Disruption
Key Insights
- Market Reality: Enterprise IT teams spend billions annually on legacy ITSM platforms like ServiceNow and Jira Service Management, creating a massive opportunity for modern alternatives
- AI's Competitive Advantage: Unlike traditional workflow automation tools, AI-powered code generation makes it faster to automate tasks permanently than to do them manually once
- Forward-Deployed Engineering: Embedding engineers directly with customers creates unprecedented feedback loops and product velocity that scales founder-led energy across the organization
- Platform vs. Point Solutions: Building complete platforms from day one—even with higher complexity—creates defensibility that point solutions can never achieve
- Talent as Moat: Maintaining exceptionally high hiring standards and focusing on candidate ability to recruit the next hire creates a powerful talent flywheel that attracts top engineers
The Opportunity in Existing Categories: Why Disrupting ITSM Matters
When Jake Stauch and Alex joined Verkada before starting Serval, they learned one of the most powerful lessons for building category-defining companies: the value of going after existing markets with existing spend. The IT service management category generates tens of billions in annual customer spending. ServiceNow dominates this space, but like many legacy enterprise platforms, it hasn't evolved with modern technology or user expectations.
This wasn't about building a "simpler" version of ServiceNow with better UX. Anyone can create a cleaner interface. The real insight came from understanding why businesses haven't migrated away from legacy ITSM platforms despite their obvious limitations. The answer: lock-in through configurability. Enterprise customers have invested years customizing these systems to their exact business processes. You can't displace them with surface-level improvements.
At Verkada, Jake witnessed firsthand how a hardware-software platform could compete in established markets by offering fundamentally better capabilities. The breakthrough moment came when Verkada introduced the ability to share camera feeds via text message—a consumer-grade experience in an enterprise context. This wasn't a feature request from customers. It was an insight born from understanding that enterprise buyers are also consumers who use sophisticated mobile-first applications at home. When they return to work and encounter 20-year-old technology, the contrast becomes unbearable.
This principle extends directly to IT ticketing. Help desk teams manage password resets, access requests, device issues, and hundreds of repetitive tasks every single day. These organizations spend enormous resources because existing platforms require manual intervention at every step. The opportunity isn't to build a slightly better ticketing system—it's to eliminate the need for manual work entirely through AI-powered automation.
The Customer Discovery Problem: Why Standard Interview Questions Fail
Early in Serval's development, Jake and his co-founder Alex conducted extensive customer interviews. They asked the standard questions: "What keeps you up at night? What's your biggest pain point?" The responses were generic and unhelpful. No IT leader spontaneously said they needed a new ITSM platform or a better workflow builder.
This insight revealed a fundamental problem with customer discovery: people don't articulate problems they've solved themselves. If an IT team has built workarounds and implemented band-aids, they don't perceive that situation as a problem—they perceive it as competence. They've handled it. It works, after a fashion.
The breakthrough came from reframing the question: "If you could hire someone today to sit next to you and do work for you, what would you have them do?"
This question bypassed ego and self-satisfaction. Instead of asking teams to admit failure, it asked what tasks they'd delegate if given unlimited resources. The answers were immediate and revealing: "Someone to handle all these access requests." "Someone to reset passwords all day." "Someone to build automations so we stop doing these things manually."
This wasn't a failure of existing tools—it was a failure of effort. Teams weren't deploying Zapier or Octa or other workflow builders because doing so required building complex logic, understanding rate limits, handling edge cases, and maintaining everything over time. For a password reset request, that meant spending days building a workflow that would only save a few hours annually. The math didn't work.
The Core Innovation: Making Automation Faster Than Manual Work
The central bet that became Serval's foundation was making it faster to build an automation forever than to do a task manually once. This required solving a specific problem: how do you make code generation work reliably enough that a non-engineer could describe what they want in natural language and receive working code?
In 2023 and early 2024, this wasn't certain. Large language models had made incredible progress on code generation, but they often failed on enterprise APIs, generated code with subtle bugs, and couldn't handle edge cases. Serval's founders bet that the trajectory of model capabilities would eventually make this viable. That bet has paid off dramatically.
Today, LLMs have become reliable enough that you can input nearly any automation request and receive code that works. The system can research poorly documented APIs, understand nuances, and generate production-ready workflows. More importantly, the models follow instructions. Serval could fine-tune them to avoid the chatbot experience—providing helpful automation without engaging in unnecessary conversation.
The practical impact is profound: IT teams can now describe a complex workflow (adding a user to Google Workspace, configuring access in five different applications, sending notifications to managers) and receive working code in seconds. The workflow executes correctly on the first try in most cases. This changes the fundamental calculus: if automation takes minutes to build instead of days, teams will automate everything.
Building a Complete Platform from Day One
Many founders entering crowded enterprise software markets choose the point solution strategy: build one powerful tool, integrate it into whatever the customer is already using, and slowly displace the entire legacy platform over time. This approach seemed logical to many observers of Serval's founding.
Jake and Alex rejected it. They decided to build the complete platform immediately: ticketing, workflows, access management, reporting, and everything else an IT team needs. This decision added tremendous complexity and risk. Why spread yourself thin building multiple products when one exceptional product could fund the company?
The answer reveals something essential about competing with enterprise software incumbents: the product experience only becomes compelling when all pieces reach sufficient maturity. When you have a mediocre ticketing system, a mediocre workflow builder, and a mediocre access management system, customers see the gaps. They compare each component to their legacy system and find everything lacking.
But when all three components reach a certain level of polish—not perfection, but sufficient maturity—customers suddenly understand the vision. They can project forward: "This is going to be really powerful. I see where this is going." That's the moment the conversation shifts from "why would I replace my current system" to "when can we start implementation?"
Building the complete platform also solved a critical problem: the workflow engine required deep API knowledge and integration capability. If Serval only built ticketing, they'd miss the primary value driver—AI-powered automation that touches dozens of enterprise applications. By building the platform holistically, the automation engine became the center, with ticketing and other functions orbiting around it.
The Discovery That Changed Everything: Rethinking Device Automation
Serval's origin story began with a specific observation from Verkada customers: devices going offline and requiring manual triage. A camera offline requires investigation, ticket creation, potential reassignment, and eventual resolution (reboot, firmware update, technician visit). This process could be automated.
When Jake and Alex tested this hypothesis with customers, the response was lukewarm. For newly deployed systems, automated device recovery would help, but it wasn't critical. However, these conversations revealed something more profound: customers faced a much larger problem. Beyond device issues, they were drowning in tickets—access requests, password resets, repeated questions that could be answered from documentation.
This wasn't a problem specific to camera systems. It was a fundamental IT operations problem: the ratio of manual requests to automated actions was inverted. Most IT work was repetitive, well-defined, and prime for automation. Yet most of it happened manually because existing tools made automation too difficult.
That insight—combined with understanding that large language models could generate reliable code for these workflows—led to Serval's true mission: becoming the platform that makes IT automation accessible to teams of any size.
Enterprise Sales and Top-Down Alignment
Building a better product doesn't guarantee market adoption when displacing entrenched incumbents. Serval discovered that selling into enterprise accounts requires mandatory top-down alignment. Middle managers and individual IT contributors might love the product, but organizational inertia prevents migration.
The most effective sales conversations start with senior leaders—CIOs, security leaders, technology executives. When these leaders see a demonstration of Serval's workflow automation in action, something clicks. One Fortune 50 CISO observed a demo showing complex automation being built in seconds and said: "Where are you located? I'm going to drive there right now. I'll be there in an hour."
This reaction comes from understanding the strategic implications: AI automation transforms IT operations from a cost center into a competitive advantage. Organizations that can execute operational changes and respond to security requirements in minutes instead of weeks gain meaningful advantage.
The second critical piece is identifying and empowering champions at implementation levels. Serval found something unexpected: their workflow builder turned IT professionals into creators. These technical professionals, given powerful automation tools, began building amazing workflows and naturally became advocates. They experienced something rare in enterprise IT: the ability to solve problems themselves, immediately, without waiting for vendors.
This creates an unusual sales dynamic: top executives provide mandate and vision, while ground-level champions prove value through their own creativity and success. That combination is remarkably powerful.
Forward-Deployed Engineers: Scaling Founder-Customer Closeness
Most scaling technology companies face an inevitable problem: as organizations grow, the tight feedback loop between founders and customers disappears. Product managers emerge. Sales engineers run implementations. Support teams handle escalations. Valuable customer insights get lost in organizational layers.
Serval deliberately chose a different model: forward-deployed engineers as core product team members. These aren't sales engineers doing temporary implementation. They're full-time software engineers embedded with customers, spending 20%+ of their time in direct customer interaction while spending the rest building product features.
The impact is remarkable. When a customer mentions a capability they wish existed, that engineer can often build it the same day. A customer requests a feature at 10 AM; it ships at 4 PM. This speed creates unusual loyalty because it combines two things customers rarely experience: being heard and being responded to.
More importantly, forward-deployed engineers solve the classic enterprise software problem: long feedback loops. In traditional models, customer feedback travels through a chain: field sales to product managers to engineering managers to sprint planning to eventual implementation. This can take months. With forward-deployed engineers, feedback becomes immediate action.
These engineers aren't building point solutions for individual customers. They're identifying patterns—capabilities that multiple customers need—and building them into the platform. The workflow builder that emerged from Serval's platform was partly designed through this forward-deployed feedback loop, with engineers seeing recurring requests and building for the pattern rather than the individual.
One specific example: Serval discovered customers wanted to invoke Serval capabilities from within Serval workflows (using the platform's own APIs). This meta-capability unlocked tremendous power—letting customers write their own features. Forward-deployed engineers identified this opportunity and built the architecture to support it.
The Talent Flywheel: Making Every Hire Raise the Bar
As companies scale, hiring quality typically declines. The conventional wisdom suggests: hire fast, build fast, iterate on people over time. Serval adopted the opposite approach: every single hire must visibly raise the average talent level of the company.
This requires discipline, especially when experiencing rapid growth and market opportunity. Serval passed on perfectly competent candidates—good people who could do the job well—if they didn't represent a clear upgrade over the existing team. This "good enough" candidate might seem fine in the moment, but over time creates a vicious cycle: lower-quality teams attract lower-quality candidates, and talent quality spirals down.
Jake's interview approach focuses on understanding agency and general intelligence through storytelling. Rather than credential-based evaluation, he asks candidates to walk through major life decisions: why certain schools, why specific jobs, what motivated career transitions. These stories reveal decision-making quality, self-awareness, and drive.
More uniquely, when evaluating candidates with the interview panel, Jake asks: "Who at this company is this person better than?" Not comparing the candidate to some abstract bar, but directly assessing how they rank among current team members. If a candidate would be in the bottom quartile, the answer is no—even if they're objectively skilled.
This creates a compounding advantage: great people want to work with other great people. As Serval's team became visibly excellent, recruiting became easier. The company created a talent vortex—a gravitational pull that attracted top engineers. Referral rates skyrocketed because current employees wanted to bring in people even better than themselves.
The secondary advantage is recruitment as a hiring criterion. Serval evaluates candidates on their ability to recruit. Will this person bring others with them? Will future candidates be more likely to join because they meet this person? Some hires became tiebreakers precisely because their network, profile, and personality made them likely to bring future great candidates into the organization.
Code Generation and the Goldilocks Moment for AI
When Serval started, code generation was a bet. Models couldn't reliably generate working production code for enterprise IT workflows. There was no guarantee they'd ever reach that capability.
Today, that bet has paid off beyond expectations. Models are reliably excellent at generating IT automation code. But this raises a strategic question: what happens if models become so good that they commoditize what Serval has built?
Jake thinks about this constantly. He identifies his biggest competitor as "the competitor that doesn't exist yet—the one that will emerge in a few years with better models and more compute." That company might be able to recreate much of what Serval built faster than Serval originally built it.
This creates urgency to invest in defensible moats that won't be undercut by model improvement. Serval is exploring next-generation capabilities:
- Autonomous requirement understanding: Can AI automatically convert business requirements into automation without human translation?
- RPA and UI automation: Beyond API-based automation, handling tasks requiring clicking, logging in, and manual changes in tools without clean APIs
- Organizational knowledge capture: Understanding each organization's unique policies, processes, and context without explicit human explanation
The deeper insight: Serval is racing to solve increasingly difficult problems today, problems that will remain difficult even as models improve. This matches Jake's learning from Verkada: go after hard things that are harder for other people. Once you've solved them, it's much harder for competitors to catch up.
Why This Moment Exists for New Entrants
Enterprise software is normally dominated by incumbents. Workday, ServiceNow, and Salesforce seem impregnable. Why is there space for new companies like Serval today?
The answer lies in AI's specific impact on configurability. Legacy enterprise software won wins through configurability—the ability to adapt to each organization's unique business processes. This was incredibly difficult to replicate. A startup could offer simpler UI and better UX, but couldn't match the flexibility of systems with decades of customization capability.
AI changes this equation fundamentally. A modern platform using code generation can achieve equal or greater flexibility than legacy systems while remaining easy to configure. Startups can offer both simplicity and customization—the combination that previously only large enterprise platforms could provide.
Additionally, large platform companies face the classic innovator's dilemma: protecting existing revenue while adopting disruptive technologies is genuinely difficult. They can't make radical changes that would break backward compatibility or deprecate existing functionality. So they're naturally slower to fully embrace AI capabilities.
This creates a window—potentially a 3-5 year window—where well-executed startups can establish category leadership before incumbents fully adapt. The land grab dynamic of 2025 is real and urgent. Companies moving quickly can position themselves as category leaders, establish customer relationships, and build defensibility faster than ever before.
The Product Discovery Tension: Existing Categories vs. First Principles
Jake credits much of his product thinking to two leaders from Verkada: Hans (Chairman) and Philip (CEO). Hans focused on existing categories—finding massive spending categories like video surveillance and building better products within those categories. Philip approached products from first principles—if we were building this today, what would it look like free from historical constraints?
These perspectives create tension, but that tension is productive. Many startups make one of two mistakes:
Category blindness: Ignoring why categories exist, what they represent, and what customer needs they address. Building something completely new that discards proven category wisdom.
Historical lock-in: Accepting category definitions as immutable law, unable to imagine how to reimagine them.
Serval explicitly combines both approaches. The company chose to compete in the ITSM category because massive customer spending exists there—companies demonstrably need IT ticket management and workflow automation. But Serval rethinks how this should work with AI. The result: a system of record that combines traditional ITSM with AI agents that automate requests and help teams build their own solutions.
This is neither "traditional ITSM with AI bolted on" nor "completely reimagined IT operations without any connection to historical category." It's a synthesis that honors both the market reality of where enterprise IT spending concentrates and the opportunity to fundamentally reimagine how those capabilities should work.
Scaling While Maintaining Quality and Vision
Serval's success creates a final challenge: how do you scale from dozens of people to hundreds without losing what made the company great?
The company made contrarian decisions about go-to-market, building a full sales organization upfront rather than gradually evolving from founder-led sales. They're also investing aggressively in forward-deployed engineering at scale—trying to maintain that tight customer feedback loop as the team grows.
The talent-based approach to everything—hiring, product, customer relationships—is the common thread. If you hire exceptional people who understand customers deeply, maintain relentless product focus, and empower them to move fast, the organization scales while maintaining founder-energy.
This requires faith that the hard things you solve early—like the code-generation-based automation engine or the forward-deployed engineering model—create defensibility that competitors will struggle to replicate. And it requires continuous investment in new hard problems before model improvements and competitive entry make them easy.
Conclusion
Serval's story illustrates essential principles for building world-changing companies in crowded categories: identify enormous existing markets with proven customer need, understand why incumbents dominate (and build something better), solve the authentic problem rather than the stated problem, invest in defensible technical approaches early, and build organizations around exceptional people deeply embedded with customers.
The company is positioned at an interesting intersection: the urgency of enterprise AI adoption, the technical feasibility of code generation reaching reliability, and the founder team's deep experience in scaling enterprise products. Whether Serval achieves its ambition to become the next-generation system of record for IT operations remains to be seen, but the combination of conviction, execution speed, and customer validation suggests they've identified something real and rare.
Original source: Go hard early: How lessons from Verkada shaped this AI-native IT platform | Jake Stauch (Serval)
powered by osmu.app