John Howrey
Design Leader
ContactCURRENTLY DigitalOcean
PREVIOUSLY SCAD
IBM
Skeptic
Philographica
Selbert Perkins Design
CASE STUDIES
Set Users Up for Success
Empowerment by Design
Driving Growth Through Design
All the World’s a Map
Luxury Reimagined
ABOUT Who I Am, What I Build
Philosophy of Leadership
wRITINGS We Don’t Need Another Framework
Design Leadership Is Cultural Leadership
Designers Should Own the Narrative
Speed and Substance Can Coexist
Collaboration Is the Work
Design as Stewardship of Experience


We Don’t Need Another Framework: On Experiential Authority in Design Leadership
There are two kinds of performance in design.

The first kind is essential: how someone shows up in the work. How they notice the tension in a conversation. How they help a team move forward. How they respond when things get ambiguous or political or just plain hard. This kind of performance is about presence, craft, and consistency. It builds trust over time.

The second kind is dangerous. It’s a performance of expertise—the kind that rewards polish over participation, posture over presence. It’s the person who talks convincingly about “driving clarity” but has never clarified a real, messy decision. The person who shows you their Figma files, but never says why they made anything. It’s expertise rendered as theater.

We keep mistaking the second kind of performance for the first. We hire it. Promote it. Sometimes we even become it. Especially in leadership roles, where it’s easier to talk about the work than to stay inside it.

We don’t need more of that.

We don’t need more frameworks, more clever diagrams, more performative rigor that falls apart the minute reality intervenes. We need something rarer, quieter, and far more durable: experiential authority.

Performed Expertise vs. Lived Experience
The design industry has become incredibly good at staging expertise. We know how to build the case study, name the artifact, and rehearse the narrative. It’s a whole performance economy—especially in interviews, portfolios, and conferences. And let’s be honest: some of it is necessary. Some of it is just how you survive.

But it becomes a problem when we confuse knowing how to talk about the work with knowing how to do it.

Experiential authority doesn’t perform. It participates. It’s the kind of leadership that doesn’t need to announce its presence because it’s already inside the product, inside the team, inside the decision. You feel it—not because someone put it on a slide, but because the work holds together. Because the team feels calm, clear, and capable. Because hard conversations happen, and no one flinches.

It’s not that these people don’t use frameworks—they do. But they don’t hide behind them. They use them as tools, not as shields.

What Experiential Authority Looks Like
You know it when you see it.

  • It’s the design lead who doesn’t just critique the pixels, but the product strategy behind them—and does it without ego.
  • It’s the person who can bridge product, engineering, and design without needing to “own” the room.
  • It’s the one who says, “We’re moving too fast to see clearly. Let’s pause,” and people listen.
  • It’s the leader who joins the critique and doesn’t take over, but makes the conversation better.

They don’t need to show how much they know. They show how much they’ve noticed.

They give clear feedback, grounded in reality. They remember what a junior designer said last week, and they follow up. They have a feel for the pulse of a team—not from surveys or dashboards, but from being there.

They don’t just talk about impact. They make space for it.

Why This Matters
When teams are led by experiential authority instead of performed expertise, everything changes.

  • Collaboration becomes more honest.
  • Feedback becomes more generous and direct.
  • The product improves—not just because someone “owned” the UX, but because people worked like it mattered.
  • Designers start taking real risks because the environment is safe enough to fail.
  • Engineers ask better questions because they trust the intent behind the work.
  • Product managers stop translating everything into roadmaps and start listening to the nuance of what users need.

The ripple effects are everywhere—but they’re especially visible in how decisions get made. With experiential authority in the room, decisions don’t get made faster. They get made better. With more clarity, less ego, and less rework.

Hiring for the Right Kind of Performance

We need to get better at hiring for real performance—the kind that shows up in collaboration, critique, and decision-making—not the kind that just looks good in a portfolio.

Ask:

    •    When was the last time you changed your mind about something important?
    •    Tell me about a time you helped unblock a team that was stuck.
    •    How do you know when your design is done?
    •    What’s the last thing you deleted from a project—and why?

Look for people who talk plainly. Who cite real tradeoffs. Who describe not just what they did, but how it felt. Who don’t need to say “I led” every five minutes.

And if you’re in leadership, show what that looks like. Be transparent about your own learning curve. Don’t perform expertise—model inquiry. Show that it’s not only okay to not know; it’s part of the job.

In Praise of Being In It
There’s a quiet power in the leader who is in it. Not micromanaging. Not hoarding decision-making. Just in it—present, listening, asking the right questions, giving others the tools to make the work stronger.

The kind of leadership that doesn’t need to talk about frameworks because they’ve already shaped one: the emotional and intellectual framework of a functioning team.

That’s the kind of performance we should be hiring for. And that’s the kind of authority design actually needs.
Design Leadership Is Cultural Leadership
How you build teams is how you build products.

Every team produces culture—whether intentionally or not. Through critique habits, Slack etiquette, hiring choices, project pacing, and how decisions get made (or avoided), culture emerges. And once it’s there, it becomes the environment in which all design work lives.

Design leaders are often asked about velocity, craft, and outcomes. But none of those exist in a vacuum. Culture is the substrate. It defines the quality of the thinking, the pace of decision-making, and the emotional weather of the team.

Before a designer sketches a screen, something else has already been designed: the conditions under which they work. Culture.

Culture Is How Intent Gets Made


Intent is often treated like it arrives from above—a strategic memo, a kickoff deck, a mission statement. But in real teams, intent doesn’t descend. It accumulates. It forms slowly, out of shared conversations, unfinished thoughts, disagreements, and convictions that finally settle into something worth building.

This is why culture matters so deeply. Culture creates the conditions under which a team can form shared intent—or fail to.

When a team doesn’t trust each other, intent fragments. You see endless revisiting of goals. You hear people say, “Wait, I thought we were doing X.” Nobody feels confident in the “why,” because nobody felt safe enough to question it when it was fragile.

When the culture is healthy, intent locks in earlier and more clearly. People know what they’re doing and why. And just as importantly, they know how to push back, reshape, and co-author that purpose together.

Culture isn’t a side effect of good work. It’s the thing that allows good work to happen.

Rituals, Language, and Structure Are How Culture Is Made


Culture doesn’t live in values statements. It lives in rituals, in language, in structure—in the daily mechanics of how people interact.

You can see culture in:

  • The way critique is facilitated. Who speaks first. Whether junior designers feel safe challenging a lead.
  • How design decisions are documented. Are they explained? Revisited? Or just implied and silently enforced?
  • How feedback flows up. Whether ICs are expected to perform certainty, or allowed to show thinking in progress.

These moments may seem small, but they are structural. They tell people what’s expected of them. They teach new hires what’s safe to say. They create guardrails or landmines, depending on how they’re handled.

Design leaders don’t just participate in these moments—they shape them. Intentionally or not, they reinforce the norms by modeling what’s allowed, what’s celebrated, and what’s ignored.

Structure is not bureaucracy. It’s care. A thoughtful structure tells people how to succeed without guessing.

Feedback and Accountability Are Cultural Practices


One of the fastest ways to see a team’s culture is to watch how feedback is given—and received.

On underdeveloped teams, critique becomes a performance. People give feedback that centers their own preferences. You’ll hear “If I were doing this…” instead of “What problem is this solving?”

You’ll hear corrections instead of questions.

But in strong cultures, feedback is generous. It lifts the designer toward their own goals, not someone else’s. The critique becomes a conversation, not a correction. There’s an emotional intelligence to it.

This is where accountability also comes into play—not the weaponized version, but the clear, humane kind. Accountability doesn’t mean assigning blame. It means being in right relationship with your work, your collaborators, and your users.

A team that avoids accountability avoids growth. A team that practices it well becomes more resilient—because it knows how to repair.

Collaboration Is Where Culture Is Tested


It’s easy to believe that culture is what happens inside the design team. But the real test of design culture is how it holds up under cross-functional pressure.

Designers don’t work in isolation. They work alongside PMs, engineers, marketing leads, support, and legal. And it’s in these intersections—these tension points—where culture either stretches or snaps.

When trust is low, collaboration slows down. People hedge, withhold, retreat. Every review becomes a performance. Every meeting is a negotiation. But when culture is strong—when people know how to disagree without damaging trust—those same tension points become creative pressure. They refine the work instead of breaking it.

The best design cultures aren’t the ones where everyone agrees. They’re the ones where disagreement doesn’t derail momentum.

The Culture That Exists When You’re Not in the Room


The truest test of leadership isn’t what happens when you’re present. It’s what persists when you’re gone.

Do decisions hold their shape? Do values stay intact? Do teammates still push for clarity, quality, and care even when no one is watching?

Design leaders eventually scale beyond individual critiques, tickets, or projects. But what they leave behind—that’s the work. The rituals they shaped, the trust they modeled, the accountability they encouraged—that’s what remains.

There’s a kind of real delegation that isn’t just about handing something off. It’s about building a system—human and operational—that can survive without your constant involvement. That’s not abdicating responsibility. That’s leadership that lasts.

Culture Is the Product



The way we gather matters. It matters because how we gather is how we live.


—Priya Parker


Culture is not the thing you do once the product is launched. It’s not a retrospective. It’s not a value engraved on a coffee mug.

It is how we decide. How we critique. How we include. How we name risk. How we act when things get hard.

The best design leaders understand this. They know that shaping the team is shaping the product. That if you want to build something durable, it starts with how people treat each other on a random Tuesday afternoon. It starts with the stories we tell each other about why the work matters—and who it’s for.

If you want to understand a leader’s impact, look at their team six months after they’ve left.

What’s still there?
That’s the legacy.
That’s the product.
Designers Should Own the Narrative
Storytelling isn’t a slide at the end—it’s the spine of the entire process.

A designer once told me—frustrated, exhausted—“I don’t understand why product keeps telling me what to design. Why are they writing the requirements? ”

My answer was blunt: “because you didn’t.”

If you don’t own the story of the work, someone else will.
Not because they’re trying to steal it. But because there’s a vacuum—and nature, like teams, hates a vacuum.

Product managers will define the problem space. Engineers will define the edge cases. Marketing will define the customer narrative. And none of them are wrong to do so. They’re trying to make sense of something that hasn’t been clearly shaped yet.*

That’s the designer’s job.

And when we abdicate narrative, we also give up influence, coherence, and sometimes, truth.

*and we can’t be upset that they don’t do it the way we would—they aren’t designers

The Narrative Is the Work



Designers often think of storytelling as a final phase—a presentational layer. We storyboard at the end. We write decks. We “position” the work.

But storytelling isn’t what happens after the design.
It’s what holds the design together.

From the first moment we meet a user problem, we are building a narrative:

    •    What’s the human situation?
    •    What’s happening that shouldn’t be?
    •    What needs to change?
    •    What would resolution look like?

That’s not a branding exercise. That’s design logic.

And if you’re not carrying that logic throughout the work—testing it, refining it, adapting it to different audiences—you’re not really designing. You’re decorating.

Our Work Is Time-Based. And So Is Our Responsibility.


Designers build journeys, not moments. We create movement—through screens, states, emotions, expectations. Our work is time-based, and so is our accountability.

A user experience unfolds. It’s sequenced.
What do they see first? When do they feel clarity? When do they feel friction? When do they feel trust?

If you’re not consciously shaping those beats, someone else is—probably in a spec doc, probably with no real sense of pacing, tone, or emotion.

Don’t let someone else define your sequence.
Try this: In your next kickoff, draw the user’s journey first—not the flowchart, but the emotional arc. Where’s the tension? Where’s the relief? Where’s the moment that makes the whole thing worth it?

That’s storytelling. That’s design.

If You Can’t Explain It, It Doesn’t Matter How It Looks


A beautiful UI that can’t be explained in plain terms is just ornament. You should be able to walk someone through your work in human language. Not buzzwords. Not design jargon. But real narrative:

    •    “Here’s what we learned.”
    •    “Here’s the moment we’re designing for.”
    •    “Here’s why this matters.”
    •    “Here’s what we’re asking the user to understand or believe.”

If you can’t explain your work with clarity, it’s not ready. If you wait for a PM to write that story for you, they will—through their lens, in their language.

And then you’ll be back where we started: wondering why no one gets what you built.

Storytelling Is Infrastructure


Narrative isn’t a flourish. It’s how we align teams. It’s how we know what we’re building and whether it’s working. It’s how engineering prioritizes. It’s how marketing positions. It’s how leadership advocates.

And it’s how users understand what the hell we’ve made for them.

So why are designers still being trained like storytelling is a “plus” instead of a core skill?

It’s not extra. It’s essential.

Try this: In your next roadmap review, instead of explaining what’s on the screen, explain the moment it serves. Say, “This is the moment when the user is unsure. This is what they’re seeing. This is what we’re trying to move them toward.”

Watch how fast people stop asking about pixels and start asking about outcomes.

We Translate Truth


The best design storytelling isn’t made up. It’s reported.
We don’t invent narratives—we distill them. From research. From real experiences. From conversations, workarounds, pain points, aspirations.

The most compelling design stories are honest.
And they’re tailored. We don’t tell the same story to everyone—we shape it based on what each audience needs to hear to act with confidence.

    •    To engineers: we clarify sequence and logic.
    •    To PMs: we clarify tradeoffs and purpose.
    •    To users: we clarify value and timing.

This isn’t spin. It’s translation.
It’s making sure everyone sees the same shape—no matter which part of it they touch.

Storytelling Is Design Leadership


You want to lead? Start telling the story.

Don’t wait until it’s done. Don’t wait for the deck. Don’t ask someone else to translate it for you.

Start narrating the work from day one. Give people a reason to care. Give them a reason to trust the direction. And give yourself the authority that comes from being the one who actually knows what’s going on.

Designers who own the narrative get more clarity, more alignment, and more impact—not because they talk more, but because they know what they’re saying and why it matters.

Call to Action


Try this tomorrow. In a  meeting—kickoff, sync, critique—don’t show the artifact first. Tell the story. The human story. The problem, the insight, the turning point. The stakes.

See what happens when the team understands the experience before they see the interface.

See what happens when you narrate the work, not just unveil it.

You’re not the decorator. You’re the director.
Own the narrative.

Speed and Substance Can Coexist

How to move fast without breaking the design—or the team.


“We didn’t really have time for design on this one.”

If you’ve worked on product teams for any length of time, you’ve heard that sentence. Usually delivered with a shrug. As if it’s a harmless truth, just part of how things go. But let’s call it what it is: a red flag.

Because when every project “doesn’t have time for design,” it’s not a scheduling issue.
It’s a values issue.

Design is being treated as optional. Disposable. A luxury you cut when things get tight.

And when that becomes normal—when every release is driven by engineering timelines, ticket queues, or infrastructure deadlines—design becomes ornamental at best, irrelevant at worst.

That’s not urgency. That’s organizational failure with a deadline.

“Fast or Good” Is a False Choice


Teams love binaries. Build or not. Ship or wait. Fast or good.

But in design, that binary is almost always false.
Speed and quality are not opposites.
Fast work can be good. Good work can be fast.

The real problem isn’t about speed. It’s about clarity.
Teams that are aligned, decisive, and well-scoped can move incredibly fast without sacrificing quality. The bottleneck is rarely design. It’s indecision. Vague ownership. Last-minute pivots. Strategy changes masquerading as urgency.

Design doesn’t slow things down—unclear priorities do.

Clarity Is the Fastest Tool You Have



Strong design brings clarity to the work. It gives decisions shape. It makes scope visible. It reveals tension before it turns into risk. It forces teams to name the real problem, and then it proposes a coherent way to solve it.

That clarity speeds up every downstream function—engineering estimates, product tradeoffs, QA testing, go-to-market strategy. It lets people act with confidence because they actually understand what they’re doing and why.

Good design is the opposite of delay. It’s momentum with direction.

Try this:
At your next kickoff, don’t lead with screens. Lead with stakes. Define the moment in the user’s life you’re trying to change. Then explain what happens if you get it wrong.
Suddenly “just ship it” doesn’t sound so strategic.

Craft Is Not the Enemy of Speed



Somewhere along the way, “craft” became shorthand for indulgence. Pixel-pushing. Preciousness.

But real craft is not slowness. It’s judgment.
It’s the ability to move quickly without compromising coherence or care. It’s knowing what matters, and when.

Designers with good craft don’t waste time perfecting everything. They focus on the moments that carry the most weight. They build flexible systems. They know where fidelity adds value and where it doesn’t.

Experienced designers are fast not because they’re cutting corners—but because they’ve built the instincts to skip the right ones.

Try this:
In critique, ask: “Where does the user feel this most?” Zoom in there. Let the rest carry that moment without distraction.

Process Isn’t the Problem. Bad Process Is.



When design gets cut for time, it’s often because the process around design feels bloated, bureaucratic, or slow.

And let’s be honest—sometimes it is.

Slide decks no one reads. Overlong Figma walkthroughs. Workshops that generate stickies but no decisions.

That’s not process. That’s performance.

The solution isn’t to kill process—it’s to design a better one. One that scales, invites participation, and moves at the speed of product.

Good process is lightweight, focused, and generous with clarity.

  • Live sessions instead of scattered async comments
  • Modular design systems that reduce repetition
  • Clear critique rituals that sharpen ideas instead of muddying them

Design doesn’t need less time. It needs a better engine.

Try this:
Map your current process. What creates clarity? What creates drag? What’s sacred, and what’s habit? If it doesn’t help the work move forward, redesign it—or cut it.

Urgency Without Integrity Becomes Damage



Urgency is good. It creates energy, focus, pace. But when urgency overrides design, it becomes something else: panic.

And panic is corrosive.
It produces rushed decisions. It sacrifices empathy. It introduces usability debt. It burns teams out and leaves users stranded.

But even worse, it reshapes the entire product in the image of the backend.

When design is sidelined, the experience becomes a reflection of the system—not the user.

You start designing for the database.
You prioritize what’s easy to query, not what’s meaningful to experience.
The interface becomes a visual schema—not a human solution.

You didn’t build an experience. You built an admin panel with lipstick.

That’s not speed. That’s surrender.

Call to Action


Try this tomorrow.

  • Start your next sprint planning by asking: “What is the most human moment in this experience? What deserves our attention?”
  • In your next stakeholder review, say: “This is the part that feels rushed. If we cut this corner, here’s what the user loses.” Make the tradeoff explicit.
  • In your next product launch, ask: “Does this design reflect urgency and intent?” If it doesn’t, it’s not ready.
 Speed is not the enemy. But speed without design is just motion. Design is not what slows you down. Design is what lets you move forward without losing your way.




Collaboration Is the Work

Design doesn’t happen alone. And it doesn’t happen without consequences.


A designer once told me, “I designed this,” and I said nothing. She presented the work in a critique—clean, coherent, and clearly hers in the most immediate sense: she had assembled the files in Figma, refined the flow, and walked us through each moment with clarity. But I knew the history. I remembered where the ideas had started. A sketch pinned to the wall by a teammate. A long Slack thread that reframed the approach. The influence of a design review two weeks earlier that had completely reshaped the layout.

She didn’t mean harm. She just didn’t name the others. And when people noticed—when they came to me afterward, quietly, to say “hey, that wasn’t just hers”—I realized I’d made a mistake too. I had let the moment pass. I had let the work speak without its full history. I had reinforced the myth that good design comes from individual genius rather than from the web of collaboration that actually sustains it.

That moment taught me what I wish I had learned earlier in my career: that we often treat collaboration as background noise, when it is, in fact, the main event.

Design doesn’t just depend on collaboration. It is collaboration—at every level, in every direction, and across every surface of the work.

Designers Are Trained for Individuality, but Deployed Into Systems



From the start, most of us are trained to operate as individuals. We are told to craft a personal portfolio. Develop our own taste. Speak to our own process. Tell our own story. The narrative of the singular designer—clever, autonomous, distinct—is so baked into our early education that we don’t even notice it shaping how we approach the work. And for a while, it serves us well. We find our voice. We learn how to articulate it.

But product work doesn’t reward individuality in the same way. Real product design is porous. It’s shaped by people across disciplines and timelines and reviews and roadmaps. A strong design isn’t the result of a brilliant individual—it’s the outcome of alignment. Of feedback taken and re-taken. Of pivots made in collaboration. Of decisions weighed across engineering, product, research, and support.

In this world, insisting on singular authorship is not just inaccurate—it’s isolating. It undercuts the very fabric of trust and shared intent that makes a product strong.

The moment a designer says “I did this,” they may be claiming ownership, but they’re also risking disconnection. They’re positioning themselves outside of a team that was, in truth, inside the work all along.

And the team will feel it.

Within-Design Collaboration Is Just as Fraught



Collaboration challenges us even within our own discipline. I’ve seen this up close. I once had a senior designer on my team—generous, talented, and deeply committed to the group’s success. She’d quietly support her peers, especially the newer ones. She’d hop into their files, help unblock tricky flows, suggest subtle improvements, finesse interactions that weren’t quite landing. She’d do all this without ever needing her name on anything. She wasn’t looking for credit. She just wanted the work to be good.

And it was. Deadlines were met. Reviews went well. Everyone looked good.

Until one day, she quit.

In our exit conversation, she told me she felt invisible. She had given her time, her ideas, her care—and received almost nothing back. No Slack shoutouts. No names in retros. No public praise. Not even private acknowledgment from the peers she helped. She wasn’t bitter. But she was done.

And I couldn’t argue with her. Because I had seen it happen, and I had let it slide.

I had mistaken collaboration for culture.

I had believed that generosity would naturally be met with gratitude.

But the truth is, generosity without recognition becomes erasure.

It teaches people that supporting others quietly is the fast track to being forgotten.

And we lose the very people who hold teams together.

Public Praise Is Design Infrastructure



I’ve come to believe that public acknowledgment is one of the most underrated tools of leadership. Not because it flatters egos, but because it clarifies the shape of the work.

When you publicly name someone’s contribution—especially when it wasn’t obvious, especially when it wasn’t in the spotlight—you send a signal: We see you. And that signal travels. It becomes part of your team’s emotional architecture. It teaches people what matters.

Credit is not just a moral act. It’s a structural one. It makes labor legible. It strengthens trust. It reminds people that they belong.

And praise, when given well, doesn’t dilute ownership. It deepens it. It makes clear that no great work happens alone—and that acknowledging complexity isn’t a weakness, but a mark of leadership.

Collaboration Changes with Power



There’s another story I’ve carried with me for a long time—one that’s harder to tell.

Early in my career, I had a colleague who helped me grow. They believed in me, opened doors, gave feedback that made me sharper. I wouldn’t have gotten my first promotion without their support. I saw them as a mentor, and later, a peer. We landed at the same level, working on the same initiatives.

But the dynamic never really shifted. They still saw me as junior, as the person they had shaped. I noticed it in meetings—my input being dismissed, or redirected, or quietly overwritten. I noticed it in 1:1s—when I’d raise a concern and be met with deflection, not engagement.

I had changed. Our relationship hadn’t.

That’s the thing about collaboration: it only works when people grow together. When power adjusts as context shifts. When trust is re-negotiated over time. If it doesn’t, it turns into a performance of partnership, not the real thing.

Designers aren’t immune to power. We need to name the dynamics we inherit and the ones we perpetuate. Because collaboration without equity is just dependency in disguise.

Cross-Functional Work Is the Work


If we’re being honest, much of design doesn’t happen in the design file. It happens in conversations, in planning meetings, in quiet 1:1s with engineers, in the 15 minutes after a review where you reframe a decision. It happens in tension—between tradeoffs, between strategies, between humans who see the world differently.

Designers who thrive in product environments are the ones who learn to navigate those tensions with grace. They translate across disciplines. They name assumptions. They slow down conversations that are moving too fast, and speed up ones that are stuck. They make the invisible visible, the complicated understandable, the emotional navigable.

And they do it without asking to be the smartest person in the room.

  • They do it by listening.
  • By making others feel smarter.
  • By making the room better.
  • That’s not a soft skill. That’s infrastructure.


    Collaboration Is a Design Skill


    We need to stop treating collaboration as chemistry. It’s not about being easygoing or agreeable. It’s not something you either “have” or “don’t.”

    Collaboration is design.

    It requires deliberate choices:

    • What meetings to attend, and how to show up in them
    • When to challenge and when to yield
    • How to give feedback that moves the work without flattening the person
    • How to hold disagreement without collapsing trust
    • How to build rituals where everyone can contribute, not just the loudest voices

    You should be able to show your collaborative thinking the way you show your visual thinking. With intention. With reflection. With pride.

    Try this


    In your next design shareout, include a slide that credits collaborators. “This part came from an idea shared by Dev.” “This flow was shaped by feedback from product.” “Research helped us realize we were solving the wrong problem.”

    Don’t just show what you made. Show how it came to be.

    The Real Work Is the Relationships


    Design systems matter. Design tools matter. But in the end, your design culture is defined by relationships.

    How you treat one another.
    How you remember each other.
    How you make space.
    How you repair.

    If we want to build better teams, we have to treat relationships as real work. Not fluff. Not vibe. Not bonus points. Core infrastructure. Something worth investing in. Protecting. Designing for.

    My Process Is People


    I don’t have a framework for collaboration. I don’t have a canvas or a workshop or a maturity model. What I have is practice. Rehearsal. Repetition.

    I learned how to build creative alignment by doing it. Probably first in a summer camp classroom, teaching fidgety kids how to move in unison for a dance they didn’t understand. Later, conducting a choir, helping people with very different voices land a shared note. And now, in product teams—helping people bring different roles, different expectations, different egos into something shared.

    The secret isn’t magic. It’s care. You try. You listen. You rehearse. You do the work. You get it wrong. You repair. You do it again. Until trust forms. Until the team becomes real. Until the machine runs.

    Collaboration isn’t chemistry.
    It’s choreography.

    And the best teams don’t just hope for alignment.
    They practice it.


    Design as Stewardship of Experience

    Design isn’t decoration. It’s responsibility.


    Let’s start here: if you are a designer, you are shaping the world. Every interaction, every decision, every default setting and visual emphasis and empty state—each one tells a story about what matters. About who matters. And each one teaches the user what to expect next time.

    You are not just moving buttons around. You are determining how someone will feel in a moment they didn’t choose, while using a tool they may not fully understand, to complete a task that likely carries weight in their day or their job or their life. That’s not a neutral act. That’s not a creative flourish. That is an exercise in power.

    And if that feels dramatic, good. It should.

    Because what we’ve allowed design to become in too many organizations is performance. Style. Presentation. We obsess over flow and motion and “delight” while quietly offloading all the responsibility for consequence onto someone else—product, engineering, support, compliance. But let me be clear: design has consequences. If the user doesn’t understand the flow, that’s not an edge case—that’s a failure of design. If someone clicks the wrong button because the hierarchy was misleading, or misses a setting because it’s buried in complexity, that’s not a support issue—that’s a design decision. If a user comes away from your product feeling stupid, manipulated, or alone, that is not a surprise. It is the outcome of what you shipped.

    And here’s the thing: they will never blame you for it. They will blame themselves. Which means it is our responsibility to speak for the person who can’t name what went wrong. To advocate for the experience they should have had. To shape the systems that shape behavior.

    This is what stewardship looks like. It’s not about control. It’s not about protecting your “vision.” It’s about protecting the humanity of the people on the other side of the screen.

    You can feel it in the small moments—what the error message says, what happens when the connection drops, how long it takes someone to undo a mistake. It shows up when you design something to feel effortless, not because you added motion or polish, but because you actually understood the intention behind the task. You respected the person’s time. You gave them clarity instead of friction. That’s not just UX. That’s care. And care is not something we add at the end. It is not extra. It is the job.

    And let’s talk about systems. Because scale is where care goes to die. We build design systems so we can move faster, with consistency. But consistency without judgment is just mass production. If you’re applying components without thought, without interrogation, without asking whether this pattern serves the user’s need in this moment, you’re not designing—you’re decorating. Your work is no longer adaptive. It’s indifferent. Aesthetic coherence without experiential coherence is nothing.

    This is the shadow side of scale. And it’s where leadership must show up. Not with vision decks. Not with playbooks. But with presence. With rigor. With the kind of cultural pressure that says: we design for impact, not just interaction. We prioritize understanding, not just polish. We build teams who know that the job isn’t finished when the file is handed off—it’s finished when the user finds ease, or relief, or power in what we made.

    That’s what we’re here to do. And if we don’t do it, no one will. Because no other discipline sits at the intersection of feeling, function, and framing the way design does. We’re not consultants to the experience—we’re its stewards. Its historians. Its advocates. And its authors.

    So let’s act like it.

    Let’s stop asking for permission to care. Let’s stop pretending that we don’t see the tradeoffs. Let’s stop hiding behind “just doing our part.” There is no part. There’s only what the user actually experiences.

    And that experience is your responsibility.

    Design like it matters. Because it does.

    Design like someone’s future behavior depends on it. Because it does.

    Design like you’re accountable for the emotions you cause, the assumptions you reinforce, the dignity you preserve—or deny.

    Because you are.

    This is what it means to be a designer now.

    Not a decorator. Not a deliverable machine.

    A steward. A shaper. A practitioner of care.

    And if that doesn’t excite you, you’re in the wrong field.

    But if it does—then step up.

    There’s real work to do.