About Dan Williams
I’m a builder and a leader. I write code and I build teams. For the last twenty years, I’ve been at the intersection of financial complexity, emerging technology, and human autonomy—sometimes leading large engineering organizations, sometimes building systems from scratch—solving problems that most organizations discover a bit too late, once they’re already scaled past the point of quick fixes.
The Journey
I started in telecoms doing network engineering—building and scaling the infrastructure that moves data globally. From there, I moved into banking where I learned something that stuck: the systems you build reflect the values you embed in them. I’ve spent two decades exploring this across fintech trading platforms, high-scale e-commerce systems, cloud modernization programs, and now Web3 infrastructure—working across multiple countries and industries, noticing how the same patterns show up in surprisingly different places. Telecoms to finance to blockchain: the pattern is always the same. Build reliable systems, make them observable, keep them transparent.
At Attekus (Director of Engineering), I’m exploring GovTech modernization with AI and emerging capability frameworks—trying to bring real agency and autonomy into government technology without sacrificing transparency or auditability. It’s where I’m learning something valuable: you can have powerful systems and transparent systems, if you design intentionally for both.
Before that, I led engineering at SelfWealth (Australia), where we scaled fintech systems for millions of transactions. Earlier in my career, I worked across both sell-side and buy-side: building electronic trading and derivatives platforms at JP Morgan, and working with trading firms and financial institutions like HSBC and Tibra Capital. That dual perspective—seeing markets from both the infrastructure layer and the trading floor—gives you deep insight into how markets actually move and what infrastructure the financial system depends on.
At Versent [AWS Premier Partner, Australia] and Contino [AWS Premier Partner, UK], I worked across data, cloud, security, and application development with enterprise teams globally. Consulting at that level teaches you what breaks. You see the same pitfalls repeated across different domains and industries—the architectural decisions that seem smart but fail at scale, the security assumptions that crumble under pressure, the data problems that destroy systems. That pattern recognition is invaluable.
I’ve also started three different companies. They didn’t all succeed, but that’s where I learned the most. MBAs are valuable, but there’s something about putting your own time and money on the line that clarifies what actually matters. You learn fast when the consequences are real. That experience—the failures, the pivots, the market lessons—fundamentally changed how I think about building products and leading teams.
What I keep noticing: the systems we build sit between intention and reality. They’re where promises either get kept or broken. I’ve come to believe they should be kept transparently, not through obscurity or hidden complexity. The industry or geography changes, but that principle seems to hold up.
What I Actually Do
I lead engineering teams and work on systems that try to make hard problems visible and more solvable. These are the areas I find myself returning to:
Technology leadership: Building high-performing engineering organizations that ship with velocity while maintaining clarity about what they’ve built and why. Leading product strategy, technical direction, and teams across full-stack challenges.
DevOps & Fast Flow: I believe in removing friction from how teams build and ship. That means infrastructure that gets out of the way—good observability, automation that actually works, deployment pipelines that don’t require heroics. Fast flow isn’t about speed for speed’s sake; it’s about feedback. The faster you can ship, test, and learn from production, the better decisions you make. This applies whether you’re running trading systems, modernizing legacy infrastructure, or building agentic products. It’s why I open-source my work—Gatekeeper and SpecChain are both public, not because I need external validation, but because building in the open forces clarity and accelerates learning.
Agentic AI & Autonomous Systems: I’m a believer in agentic development—using AI and autonomous processes to solve real problems today. At Attekus, that means spec-driven development where AI agents help write code directly from specifications. It also means building products with AI-enabled workflows and UI-less design—interfaces that disappear and let the system do the work. Autonomous AI systems capable of decision-making are viable now; the interesting challenge is figuring out what they should actually do and how to build them into products that work.
Systems architecture: I work on systems that need to be reliable, observable, and transparent. Whether it’s trading systems, settlement infrastructure, or blockchain work—the problems tend to be similar: find what breaks, fix it thoughtfully, keep it understandable.
Web3 & Real-World Asset Tokenization: I’m convinced that tokenizing real-world assets on blockchain—bonds, property, commodities, derivatives, the full spectrum of what moves through financial markets—is inevitable. And necessary. Having built TradFi infrastructure at JP Morgan, I’ve seen firsthand how much friction and opacity lives in those systems. Blockchain offers a different path: transparent, auditable, programmable.
That’s why I’m building SpecChain. The core idea: let on-chain contracts define what’s allowed (the policies), then make sure every API layer that touches those assets enforces those rules automatically. No hidden logic. No “trust us.” Just code that does what the chain says it should do.
Supporting that are tools like Gatekeeper for authentication that works for both humans and autonomous agents, and RPC abstractions that treat node reliability as first-class. When tokenized real-world assets are flowing through autonomous systems, you need infrastructure you can actually verify.
The technical stack varies—Go, Python, TypeScript, Node.js, distributed systems design, Kubernetes, infrastructure-as-code, AWS and Azure. But the philosophy is constant: respect the user’s right to understand and audit what’s happening.
Why This Matters: Transparency & Freedom
Here’s what I’ve come to believe, maybe too strongly: I’m a freedom maximalist. Not perfectly, but genuinely. I believe:
- Systems should be transparent, not opaque
- Users should have agency, not be manipulated by dark patterns
- Code should be auditable, not hidden behind corporate vaults
- Power should be distributed, not concentrated
Web3 resonates with me on this. Not perfectly—it has its own problems—but it’s built on these principles. That’s partly why I’m interested. Blockchain fascinates me not because of tokens or speculation, but because it’s the first time we have tools to build systems where you can actually verify what’s happening. Where trust is something you can check, not something you just grant.
I think the same applies to AI and autonomous systems. When machines start making real economic decisions, “trust us, it works” isn’t enough anymore. You need transparency. You need auditability. You need to understand why a decision happened. That’s not academic—it’s practical infrastructure.
Here’s what I think is actually happening: tokenized real-world assets + autonomous agents (that are already emerging today) + transparent infrastructure = a fundamental reshaping of how value moves and settles. Markets today depend on opacity—complexity that creates rent-seeking opportunities. Blockchain removes that. When property, bonds, commodities are on-chain and machines can autonomously act on them, you can’t hide anything anymore. The agents are coming. The question isn’t if they’ll exist—it’s what infrastructure we build for them today.
That’s not a small thing. It’s a shift toward systems where trust is computable rather than granted. Where rules are enforced by code, not by institutions. Where the money itself (or the assets) can’t be secretly devalued by policy decisions. It echoes why Bitcoin was built—sound money that can’t be inflated away. But it scales: not just currency, but everything of value.
I’m not saying this is simple or that I have all the answers. But I’m convinced enough to build the infrastructure for it. SpecChain to define policies. Gatekeeper to authenticate who can act. Systems that keep autonomy transparent and grounded in verifiable rules, not institutional trust.
That’s where I’m focused right now. Trying not to just port Web2 thinking into Web3. Trying not to build systems that work but no one understands. Experimenting with infrastructure where every decision—every asset movement—can be traced back to clear, auditable rules.
Open Source & Ideas
I’ve found that the best way to test infrastructure ideas is to build them openly. Gatekeeper (an authentication and policy enforcement layer I’ve been working on) is open-sourced on GitHub with tests and documentation. It’s my attempt at proving these problems are actually solvable.
I share what I’m learning on this blog—field notes on building systems, the decisions that seem to matter, and what might be coming next. I’m still figuring a lot of this out.
Let’s Talk
If you’re working on these kinds of problems—building on-chain products, modernizing infrastructure, thinking about systems for autonomous agents, or exploring agentic development—I’d genuinely like to talk. Especially if you’re seeing things differently or questioning my assumptions.
GitHub: roguedan LinkedIn: dtwilliams1
I’m based in Melbourne (Australia) but work across timezones—currently split between Australian Eastern and Brazil time.