I joined Salesforce's Builder org during a transition, ramping on a product that spans no-code, low-code, and pro-code experiences built by many teams. The hardest part wasn't the work. It was finding it: resources, links, and decisions scattered across Slack canvases, Figma files, and research docs that no one had time to gather in one place. I decided to build that place.
Builder Hub started as a site to onboard myself and grew into a knowledge system for twelve builder teams. It has an agent you can ask, feeds that keep themselves current, and one way to search across all of it. I designed and built the whole thing end to end, including the parts a designer isn't expected to touch.
It's the clearest example of how I work now: when the tool I need doesn't exist yet, I build it, all the way to something running and in use.
Give every builder team, and anyone joining one, a single place to find the work, see how it fits together, and search across all of it.
I had time in the transition and a choice about how to spend it. I could read scattered docs until I'd pieced the picture together for myself, or I could build the thing that pieced it together for everyone after me. I went with the second. My bet was that onboarding pain is a symptom of a missing system, not a missing wiki page, and that a designer is well placed to build that system, because the whole job is making complex information findable and clear.
It grew in layers, and each one solved the next problem the last one surfaced. Jump into any part.
The Builder product is genuinely complex, spanning no-code, low-code, and pro-code experiences across many teams. The information to understand it was real, but scattered: Slack canvases, channel threads, Figma files, research readouts. To answer a basic question, who owns this, what's the latest research, where's the current design, you had to know which of a dozen places to look and who to ask.
For someone new, that's a wall. For the teams themselves, it's a quiet tax: the same questions re-answered, the same links re-shared, work duplicated because no one could see what already existed. The resources were never the problem. The missing system around them was.
I started small, and a little selfishly, in the best way. I built one site for my new team that pulled together everything I needed to ramp: the canonical links, the design files, the research, the people and what they own. Building it was how I learned the product. Every resource I tracked down and placed was something I now understood, and something the team could reuse instead of rediscovering.
The principle I held: it had to be lower-effort to use than to ignore.
If keeping it current was manual, it would rot like every wiki before it. That one constraint shaped everything that came next.
A knowledge site is only worth trusting if it's current, and current is exactly what people are worst at keeping up. I made the site maintain itself. A scheduled job runs three times a week, scans the team's Slack, and pulls in anything new, fresh research, new Figma files, updated resources, then surfaces it in a live feed so the team sees what changed without going looking.
This is where I stopped requesting tools and started building them. It runs on Claude Code with the Slack MCP, on a schedule, with no one in the loop. The design decision underneath it is about attention: the feed shows what's new since you last looked, not an undifferentiated dump, because the value is saving people the hunt, not relocating it.
Gathering isn't understanding. The next layer turned the collection into something you could reason over. I added a place to synthesize research across sources, so shared findings and contradictions surface instead of staying buried in separate readouts, and a way to look across the architecture and designs themselves.
The piece that ties it together is an "Ask the Hub" agent. Instead of knowing which canvas to open, you ask a question and it routes you to the right tool, pulls cross-team research into one view, and can even check a PRD against our trust and autonomy principles. It's the difference between a library and a librarian.
Once it worked for one team, the obvious question was why stop there. Every builder team had the same problem, and we were all heading to an internal builder summit where the whole ecosystem would be in one room. I scaled it. I built a separate site, with its own repo, for every builder team we knew of, seeded with all the resources I could reach, and handed each one off to its team to own and grow.
Above them sits the Builder Hub: a parent that pulls from all twelve team sites and lets you search across the entire ecosystem at once. Compare how different teams approach the same problem. See the architecture side by side. Find who works on what. As each team fills its site with richer research and design files, the whole system gets sharper, and the places where we should be driving consistency get easier to see.
I built Builder Hub end to end, including the parts a designer usually hands off. That's why it's here. The judgment that used to stop at a spec now runs all the way to a working, governed, deployed system.
Wrote the scheduled jobs that scan Slack and refresh every site on their own, three times a week, with no one in the loop.
Built the cross-team agent to run client-side against the hub’s own data, so a question routes across every team’s content instead of dead-ending in a single doc, with no backend to keep alive.
Stood up a separate site and GitHub repo for each team, then handed them off individually, so every team can own and extend their own.
Wired up OIDC auth so the right people get in and internal content stays protected.
Cleared the full enterprise AI governance path myself: AI Council, RFC, and legal review. At a company this size, the design isn't done until it's allowed to exist.
Between April and August the repo took 223 commits. 124 came from automation and 99 from people. The two paths are deliberately different. People branch, open a PR, and wait: main is protected, CODEOWNERS puts me on every one, and I batch reviews Monday and Thursday. The scrapers skip that gate on purpose and commit content straight to main, so the bot never sits waiting on me. Content flows. Code gets read.
Building an agent that runs unattended means deciding what it’s allowed to do quietly, and two calls did most of that work. The decision-log scrape still times out. Rather than retry in silence, it reports the failure in the morning summary every day, where I have to look at it. A silent failure should never get to look like success.
The second is the PR-review nudge. It writes the Slack message and stops. It can’t clear the approval gate on its own, so the draft sits in my queue until I send it. The agent prepares the work. Sending it is still mine.
Builder Hub is in use internally. It started as my own onboarding and became shared infrastructure for the builder org:
The return compounds. Every team that enriches its site makes cross-team search, architecture comparison, and the case for consistency stronger for everyone. That case is being made now beyond the builder org: adoption across our wider UX org is being promoted with executive buy-in behind it.
The honest limitation is that a shared system is only as good as what teams put into it. The scaffolding, the feeds, the agent, the search, those I could build. Whether each team keeps its site rich with their latest thinking is a habit, and habits take longer to change than code does.
What I'd carry forward is smaller and more personal. I almost talked myself out of building this, because gathering links felt like below-the-line work, not "real design." It turned out to be some of the most useful work I've done. Making complex information findable and current is the heart of the job. The tools just finally let a designer build the answer instead of filing a request for it.