From Spreadsheets to Agents: My Obsession with Building Delivery Operating Systems
A Technical Program Manager's journey across two companies: turning manual chaos into governed, automated delivery.
Part I: Zalando: Building the PMO's "Second Brain" on Spreadsheets
When I joined Zalando's Global PMO, large strategic programs were run entirely through spreadsheets and Google Workspace. Spreadsheets served as portfolio overviews, resource allocation trackers, program/project managers, workstream documentation, project plans, timelines, scenario-planning tools, risk registers, decision logs, and burndown chart calculators, all in one. Docs were for documentation and reporting. Slides for kick-off decks. Bi-weekly portfolio reviews required manually assembled reports in a new document each time.
Every governance meeting (weekly program jour fixe, bi-weekly portfolio reviews with program sponsors, monthly resource reviews) demanded that every PgM manually update a dozen+ documents per program. And many of us led two or more programs simultaneously. The result: massive manual effort that stole capacity from where it actually mattered: dependency management, proactive risk identification, and faster decision-making.
I refused to accept this as "just how it works." I kept my own program artifacts meticulously updated daily. Not out of perfectionism, but because it freed my mental capacity. I didn't have to dig through files to know which week the program was in; I had it calculated and prominently displayed on my program overview sheet. I could point anyone in the org to a single, always-current source of truth. The spreadsheet was my second brain.
But there was one problem: every week, I had to spend time copy-pasting data from my local spreadsheet to centralized spreadsheets for leadership. It was manual, error-prone, and frankly beneath what a PgM should be doing.
So I wired it up.
I built formulas that connected my local program sheet to the centralized portfolio view. If my local sheet was current, the central view was current. No manual sync. No reminders. No chasing.
I demoed it to my lead, Maarten van der Most, who immediately saw the bigger picture: what if every PgM ran their local spreadsheet in a standardized way, and the centralized view stayed relevant automatically? We reviewed the POC (internally branded "Reporting v2.0") with colleagues Andi, Juan, Anne, and others who contributed refinements and optimizations. Within a month, we had the entire Global PMO portfolio running on a centralized spreadsheet tool where senior leadership could consume real-time program information: sponsors, start/end dates, stage, status (RYG), path-to-green, contributing teams, per-stage timelines, burndown charts. Without management needing to remind anyone to update anything.
This was well before Google introduced the timeline feature in spreadsheets.
The impact was immediate: PgMs got their time back. Leadership got trust in the data. The weekly copy-paste ritual was eliminated. And the foundation was laid for what came next: the Scaling Delivery Practices Playbook, a cross-GPMO initiative to create a single source of truth for project onboarding, delivery, reporting, and oversight. A unified framework owned and maintained by the Project Management Community of Practice.
Part II: Taxfix: From Spreadsheets to a Notion-Native Delivery Operating System
In 2022, I joined Taxfix, which was just founding its PMO office. This time, I didn't have to build complex spreadsheet formulas. Taxfix used Notion. I created a transparent, scalable program management setup from day one.
And this is where the story takes a turn I didn't expect.
Notion didn't have a native Projects feature yet. What they had was databases, pages, relations, rollups, and formulas. Building blocks. I used those blocks to architect a full program management system: project portfolios with linked tasks, nested objectives, automated status rollups, burndown-style progress tracking, cross-database relations for dependencies, and dashboards that gave leadership a real-time view without anyone needing to manually compile a report.
The setup worked. It worked so well that Notion noticed. They featured my approach in a case study video about how Taxfix makes projects transparent and scalable in Notion, essentially using my architecture as the story to tell the world how to run project management in Notion, before they shipped a dedicated Projects feature. In that video, I described what we'd built: a single portfolio database connected to strategy goals, where the whole company could open any project and see updates in real time. One source of truth. One language. No more stakeholders looking in five different tools, scheduling extra meetings just to get a status update.
That's the same pattern from Zalando, one level up: work with what you have, push the tool beyond what anyone thought it was for, and the tool's own creators take notice.
Then Notion brought me into their Build by Notion series in Berlin, where I presented how Notion charts were helping Taxfix transition into Marty Cagan's product operating model. The problem was concrete: engineering teams lacked empowerment, prioritized output over outcomes, and couldn't track where their capacity was going. Unplanned work sat at 33%, well above the industry standard of under 15%. Leadership didn't use Jira, so engineering managers couldn't bring data to strategic meetings.
The solution: strategic investment buckets ("keeping the lights on" = minimum 10% of team capacity), Jira-to-Notion integration via custom JQL filters, and Notion charts that made everything visible in minutes: investment buckets per sprint, unplanned work percentages per team, WIP limits, and burndown charts. No more manual reports. The charts told the story.
The results: unplanned work dropped from 33% to 22% in one quarter, a 30% reduction. For a team of 100 engineers, that meant 1,500 engineering hours saved for product work that brought value to customers. Engineering managers like Untitled were instrumental in driving that reduction on the ground. Teams shifted from talking about deadlines to talking about outcomes. Engineering managers walked into leadership meetings with live data, not hand-compiled slide decks. As I said on stage: "using charts in Notion in product development teams feels to me like having a superpower."
So let me put this bluntly: I didn't just use Notion for program management before they had a feature for it. Notion validated the approach publicly, first as a case study video, then by putting me on their stage at Build by Notion Berlin. That's not me claiming the setup worked. That's the company that built the platform saying: this is how it should be done.
But the real test wasn't building the system or getting recognized for it. It was proving it under pressure.
Peak Season Readiness: When the Operating System Has to Work
At Taxfix, peak season is everything. During Peak-2-2025, I was the DRI for readiness operations, orchestrating a Mission Control Room with dashboards, runbooks, and a cross-functional ops flow. The headline outcome wasn't a single metric, it was that we ran the highest-traffic period of the year without a change/release freeze. No freeze means the teams trusted their deployment pipeline enough to ship during peak. That trust isn't accidental. It's the output of a delivery operating system that makes risk visible early and decisions traceable.
GBB: Structuring Ambiguity into Delivery
As program lead for GBB (Good, Better, Best, originally Monetization), I structured what was an ambiguous strategic initiative into multiple projects with clear critical paths and dependencies. Phase 1 delivered on timeline before Christmas 2025. I proactively flagged delivery risks to CTO and CPO. Not to escalate problems, but to surface them early enough to act.
I made full program transparency the default: all documents in one place, all risks visible, all decisions traceable. Openly flagging issues to CTO/CPO rather than hiding them wasn't just a trust principle. It was a delivery principle. You can't mitigate what you can't see.
Leadership Rituals That Actually Work
I planned and facilitated quarterly Tech Leadership Onsites (Q3 in Madrid with excellent feedback, Q4 following) and codified learnings into improved practices: distinguishing local from wide-impact decisions, shifting formats toward pre-read-driven discussions, and introducing the "Walk-the-board" format as a weekly cross-functional status and risk review for tech leadership.
I partnered with the CTO on defining Technology OKRs for H1 2026, incorporating leadership feedback and contributing to M&A readiness: data contracts, cloud consolidation, PII handling.
AI Strategy: From Hype to Operating Model
I operationalized R&D's AI strategy: facilitated the strategy workshop, aligned objectives and follow-ups, enabled the AI Engineering team on an expert-interaction chatbot, and coordinated data pipelines and evaluation. I co-defined the AI Productivity Index for R&D (later adopted company-wide). I co-led the AI Community of Practice with the Director of AI Engineering.
I championed Notion workspace cleanup for R&D: completed the initial phase, identified champion teams, and set up a Notion-recommended architecture. Early signals from other departments validated the approach: P&O colleagues reported Notion AI agents outperforming Zapier/n8n automations built over weeks.
Part III: The Agentic PMO: Where This Is All Going
Today, the trajectory is clear. The same obsession that wired up spreadsheet formulas at Zalando and built a Notion-native operating system at Taxfix is now driving the agentic PMO framework.
The core insight: you can't accelerate what you can't see. Status reports drift by Wednesday. Dependencies get chased in DMs instead of surfaced systemically. Risks are discovered after they've already cost time.
The agentic delivery approach is built on a simple foundation: our R&D operational second brain, a knowledge catalogue built from connected Notion databases where AI meeting notes and transcripts, programs, projects, decisions, and risks all link to one another. You can trace any output back to its origin: from a meeting transcript, to the project it informed, to the documents and tasks that came out of it. An agentic PMO framework where product delivery agents read, write, and update that catalogue. Anchored in principles like #7 Write to a shared graph in standard schema (your output is someone else's agent's input; schema discipline equals network effect) and #3 Verifiable signals only (flags trace to declarative rules, not LLM vibes).
The shift is fundamental:
- Siloed notes → shared graph every agent reads
- Maintained docs → artifacts on demand (death of the weekly status update)
- Chased status → loops that surface only deltas
This isn't a tooling upgrade. It's a delivery operating model evolution: from spreadsheets as a second brain, to a connected Notion knowledge catalogue, to agents as the execution layer on top.
What Ties It All Together
The thread across every era is the same: work with what you have, make it better than anyone thought possible, and never let "that's just how it works" be the final answer.
Spreadsheets weren't a limitation. They were an invitation. Notion wasn't a fresh start. It was a scaling opportunity. AI agents aren't a trend. They're the next operating layer for a discipline obsessed with removing friction between decisions and outcomes.
The value isn't in the tools. It's in the obsession with continuous improvement, the pragmatism to use whatever is in front of you, and the willingness to build, because nobody else will, and the team needs it done.