Building Hardware Should Feel Like a Miracle
Hardware, at its best, feels like magic.
An idea begins as a sketch, a conversation, or a rough model. Then, somehow, through layers of design, engineering, sourcing, and production, it becomes real. Tangible. Functional. Scaled.
That transformation should feel like a miracle.
Too often, it doesn’t. But when it does, the acceleration of revenue becomes a case study in its own.
Where It Started
I grew up close to that miracle.
One side of my world was industrial design. The other was manufacturing. I watched ideas move from concept into physical reality, not as abstract theory, but as a repeatable, tangible process.
That early exposure shaped how I think about building. Not just the outcome, but the systems that make the outcome possible.
It’s what led me into the design-and-build ecosystem, and eventually into the problem I’ve spent my career trying to solve.
A Career in Scaling Complexity
Across each chapter of my career, the focus has been consistent: build the infrastructure that allows complex ideas to scale.
At Autodesk, I worked on advanced manufacturing software, pushing into early digital fabrication and 3D printing workflows.
At Onshape, I was part of the shift to cloud-native CAD. Version-controlled, collaborative, and built for distributed teams from day one.
At Join, we built a collaborative delivery platform used on projects at massive scale, from hyperscale data centers to large institutional builds.
Back at Autodesk Research, I led work in generative AI for automotive design, partnering with global enterprises to automate workflows that were previously considered intractable.
Different domains. Same underlying challenge.
As systems scale, coordination becomes the bottleneck.
The Coordination Tax
Today’s hardware teams are not limited by talent or ambition.
They’re limited by fragmentation.
Critical knowledge is spread across tools, teams, and organizations. Alignment happens through scattered messages, recurring meetings, and ad hoc check-ins. Decisions are made, but not always propagated. Context exists, but not always accessible.
The result is what I call the coordination tax.
It shows up as:
Delayed decisions because the right people aren’t aligned at the right time
Hidden rework caused by incomplete or outdated information
Time lost stitching together context instead of acting on it
It’s a silent drain on execution. And as complexity increases, so does the cost.
Left unchecked, it doesn’t just slow teams down. It erodes their ability to innovate.
From Heroic Effort to Systematic Execution
Most hardware organizations compensate for this with effort.
More meetings. More follow-ups. More “heroic” individuals who keep things moving through sheer persistence.
But effort doesn’t scale.
What’s needed is a shift from manual coordination to system-level orchestration.
That’s the idea behind EverCurrent.
The EverCurrent Approach
We’re building toward a world where hardware teams don’t have to chase alignment. It happens automatically.
Instead of relying on individuals to connect the dots, we introduce AI workers that operate across the workflow:
They gather signals from across systems, conversations, and stakeholders
They proactively surface what matters, when it matters
They drive decisions forward by organizing context and ensuring the right inputs are present
They create full decision traceability across the lifecycle
The goal isn’t to replace teams. It’s to remove the invisible work that slows them down.
No more waiting for the next sync. No more reconstructing context from scattered threads.
Just continuous, system-level alignment.
What Changes
When coordination becomes automatic, two things happen.
First, teams reclaim time. Not marginal gains, but meaningful capacity. On the order of 20% of execution bandwidth.
Second, decision cycles compress. Alignment happens earlier, with better information. What used to take days or weeks can happen in a fraction of the time.
The downstream effect is simple: more time spent building, less time spent coordinating.
A Different Standard for Hardware
We’ve normalized the chaos of building hardware.
The fragmented tools. The endless syncs. The quiet inefficiencies that everyone accepts as “just part of the process.”
They don’t have to be.
The future of hardware execution is not just faster tools or better models. It’s systems that are inherently aligned. Systems where information flows automatically, decisions propagate reliably, and teams operate with shared context by default.
In that world, building starts to feel different again.
Closer to a miracle.
Let’s Build Better
If your systems are scaling faster than your coordination can keep up, you’re not alone.
But it’s solvable.
I’m always interested in how different teams are approaching this problem, what’s working, and where things are breaking down. And if you’re thinking about how to move from reactive coordination to proactive alignment, I’m happy to share what we’re seeing across the teams we work with.
Because at the end of the day, building hardware should feel like what it was always meant to be:
A seamless transformation from idea to reality.