Connecting the Dots from Strategy to Execution Steve Elliott is the founder and CEO of Dotwork, an AI-native strategic alignment platform built on knowledge graphs and flexible ontologies. A serial entrepreneur with several successful exits, Steve previously founded AgileCraft (acquired by Atlassian in 2019) and served as Head of Product at Atlassian. He also co-founded The Uncertainty Project, a community-driven playbook for better organizational decision-making, and is the author of The Decisive Company. Episode Overview Why do so many organizations still run strategy on spreadsheets and slide decks? And what would it look like if AI could actually understand how your organization thinks—not just summarize its documents? In this conversation, Steve Elliott traces his path from Big Six consulting through serial entrepreneurship to the problem that’s consumed his career: strategic alignment in large, complex organizations. He unpacks why the gap between executive intent and team execution persists despite decades of tooling, and why the first generation of enterprise agility platforms—including the one he built and sold to Atlassian—ultimately couldn’t solve it. The root issue, Steve argues, isn’t cultural or procedural. It’s structural: organizations lack a durable, evolving memory of how they operate and why they make decisions. That diagnosis led Steve to build Dotwork, a platform that combines flexible ontologies, knowledge graphs, and AI to create what he calls an organizational operating system—one that can observe how work actually flows (not just how it’s drawn on slides), maintain context across planning cycles, and surface signals to leaders without drowning them in noise. Along the way, the conversation covers why operating models aren’t operating systems, how to make decisions under uncertainty, and what it would take for AI to move beyond task-level productivity to genuine systemic intelligence. Guest Links * Dotwork — AI-native strategy and portfolio platform * Steve Elliott on LinkedIn * The Decisive Company: How High-Performance Organizations Connect Strategy to Execution by Steve Elliott Tools, Frameworks & Concepts * The Uncertainty Project — a community-driven playbook of decision-making models and techniques, co-founded by Steve * Knowledge Graphs — graph-based data structures for relating organizational concepts over time * Flexible Ontologies — adaptive data models that capture how an organization thinks and evolves * One-Way Door / Two-Way Door Decisions — framework for calibrating decision speed to reversibility * John Boyd’s OODA Loop — Observe, Orient, Decide, Act decision-making framework * Team Topologies — framework for organizing teams around cognitive load and flow (referenced by Dave) * Product Operating Model — outcome-oriented approach to organizing product development work * Event Sourcing — a software architecture pattern where system state derives from an audit trail of events (referenced by Dave) People Referenced * John Cutler — Head of Product at Dotwork, author of The Beautiful Mess newsletter * W. Edwards Deming — management theorist, referenced by Dave (”by what method”) * John Boyd — military strategist, creator of the OODA loop Topics Discussed From Consulting to Serial Entrepreneurship Steve’s career began at one of the Big Six consulting firms, where the rapid rotation through large organizations gave him a front-row seat to recurring patterns of organizational dysfunction. Working on segregation of duties in ERP systems, he kept seeing the same problems resurface year after year—and realized that issuing reports wasn’t solving anything. That frustration drove him to build software that could address these problems. Key points: * Consulting provided breadth—seeing dozens of companies’ decision-making patterns in quick succession—but delivering reports felt hollow when the same issues reappeared annually * The pivot from consulting to software was driven by wanting to help customers actually solve problems, not just document them * This pattern of seeing recurring organizational dysfunction became the throughline across multiple startups The Strategic Alignment Problem The core problem Steve keeps chasing: in large organizations, executives have strategies and teams have plans, but the connection between them is fragile and constantly breaking. Plans go stale within weeks of creation, and the people tasked with keeping everything connected—what Steve calls “human glue”—can’t scale to keep pace with organizational complexity. Key points: * Leaders can’t see what’s working in real time; teams don’t understand why their priorities keep shifting * John Cutler’s framing of “forever problems”—alignment will never be fully solved, but getting meaningfully better at it changes everything * It’s often mislabeled as a culture problem when it’s actually a visibility and structural problem * The faster organizations move (flatter structures, AI adoption, tool proliferation), the harder alignment gets The Limits of Existing Tools Steve offers an honest postmortem on both ends of the tooling spectrum: scrappy spreadsheet-and-slides approaches that lose memory every planning cycle, and the first generation of enterprise agility platforms that assumed too much organizational consistency. Both fail for related but different reasons. Key points: * Spreadsheets and slides are cheap but create no organizational memory—every planning cycle feels like starting from scratch * Enterprise agility tools scaled process well but couldn’t scale understanding because their data models were too rigid * The fatal flaw of first-generation platforms: assuming conformity across the organization when real orgs are dynamic and constantly reshaping themselves * Steve built and sold one of these platforms (AgileCraft to Atlassian) and learned firsthand where the approach breaks down Ontologies, Knowledge Graphs, and Organizational Memory The technical heart of the conversation: Steve explains how flexible ontologies and knowledge graphs provide the foundation for a system that models how an organization operates—and evolves that model as the organization changes. The key concept is “durable context”—understanding not just what decision was made, but also what the world looked like when it was made. Key points: * An ontology is a shared language for how the organization thinks; a knowledge graph keeps those ideas connected over time * First-generation tools had their ontology hard-coded into a relational database—if the org didn’t match the model, the tool broke * Durable context means preserving the factors that surrounded a decision so you can compare past and present conditions meaningfully * Graph technology handles the networked nature of modern work while still supporting the hierarchies that matter (people, budgets, time) Operating Models vs. Operating Systems A subtle but important distinction: the operating model is the idealized version of how work should flow; the operating system is what’s actually happening on the ground. Steve argues that most organizations focus on the model and neglect the system—missing opportunities to learn from how work actually moves. Key points: * Operating models are like class diagrams; operating systems are like runtime behavior with observability * The gap between model and system is where the most valuable coaching and organizational design insights live * If teams are getting better outcomes by working outside the prescribed model, that’s a signal to update the model—not enforce compliance * Being able to observe both and compare them is a genuinely new organizational capability Dotwork’s Vision: Intelligence Without More Dashboards Dotwork’s approach is deliberately different from the “log into our dashboard” paradigm. Steve describes a vision of a “dark system”—a context engine with organizational memory that surfaces relevant signals to leaders wherever they already work, without requiring them to learn yet another tool. Key points: * Rather than pulling all data into one system via heavy connectors, Dotwork uses AI to progressively retrieve just the specific metrics and signals that matter * The goal is to eliminate status meetings and planning overhead by making alignment observable and continuous * The vision: an AI that knows both you (like a personal GPT) and your organization, enabling higher-value work * Leaders consistently ask for the same thing: help me look around corners and see second-order impacts before they become expensive mistakes AI Beyond Task-Level Productivity The conversation closes with a broader look at where AI creates systemic value versus task-level value. Steve argues that the bottleneck isn’t AI capability, it’s organizational context. Without an ontology and memory of how the organization operates, AI agents are flying blind. Key points: * Current AI wins are mostly task-based (code generation, summarization); the bigger opportunity is system-level intelligence * For AI to do meaningful organizational work, it needs to understand who makes decisions, how they’re funded, and what’s been tried before * The missing piece: institutional knowledge and context that currently lives in people’s heads or is scattered across dozens of tools * Steve’s hope: leaders freed from status meetings and compliance toil can spend more time on strategy, experimentation, and building things that matter--- Hard Boiled Software is hosted by Dave Laribee. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit newsletter.nerdnoir.com
