<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Christabel Akpoguma on Medium]]></title>
        <description><![CDATA[Stories by Christabel Akpoguma on Medium]]></description>
        <link>https://medium.com/@christabelakpoguma?source=rss-fc4c2e2910f5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1rwvaEd912x3uOi0q-DFRw.jpeg</url>
            <title>Stories by Christabel Akpoguma on Medium</title>
            <link>https://medium.com/@christabelakpoguma?source=rss-fc4c2e2910f5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 22:22:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@christabelakpoguma/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your Design Isn’t Done Until It Tells a Story]]></title>
            <link>https://www.designsystemscollective.com/your-design-isnt-done-until-it-tells-a-story-4a99fad5cd2f?source=rss-fc4c2e2910f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a99fad5cd2f</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[user-stories]]></category>
            <category><![CDATA[user-research-design]]></category>
            <category><![CDATA[user-experience]]></category>
            <dc:creator><![CDATA[Christabel Akpoguma]]></dc:creator>
            <pubDate>Fri, 26 Jun 2026 11:10:37 GMT</pubDate>
            <atom:updated>2026-06-27T08:45:22.456Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ANrC-pkqz-6o2xjrnj2ReA.png" /></figure><p>I watched payroll experts stare blankly at a system we built — and realised the problem wasn’t them. We had built exactly what they asked for. But it wasn’t what they needed.</p><h3><strong>The Brief</strong></h3><p>Last year, my team and I were handed a clear brief: rebuild a payroll system that was painful to use, make it configurable, scalable, and sellable as a SaaS product. Simple enough. We got to work.</p><p>We dove into research — stakeholder meetings, prototype testing, end-to-end process mapping, reverse-engineering payroll from first principles. With a tight timeline and very little handholding from the department, we figured most of it out ourselves. By the time we were done, we were confident. We had automated the painful parts, built in scalability, and covered every requirement they’d asked for. We walked into that presentation room ready.</p><h3><strong>The Room</strong></h3><p>The stakeholders approved every process. The logic was sound. Every requirement was met. Then came the silence.</p><p><em>“It’s a lot,”</em> one of them said.</p><p><em>“Is there a way to make it simpler?”</em></p><p>Simpler? We had already simplified where we could. These were payroll experts — people who had been running payroll long before we wrote a single line of code. How could they be confused?</p><p>Some on the team shrugged it off as resistance to change. But one comment stuck with me:</p><p><em>“It’s confusing knowing what to set up and knowing where to go. The UI is really great, though. Maybe we’ll just need </em><strong><em>training</em></strong><em>.”</em></p><p>In UX, that word is a red flag. If users need <strong><em>training</em></strong> to navigate a system built for their daily work, the design hasn’t finished its job.</p><h3><strong>The Realisation</strong></h3><p>New features rolled in, tweaks and updates, the engineers adapted. But I couldn’t let it go.</p><p>I went back through the system myself — not as a designer looking at screens, but as a first-time user trying to figure out what to do next. And I felt it immediately. The answer became clear. Thirteen modules, each comprehensive and correct — and no thread connecting them. Every screen answered, <em>“What can I do here?”</em> but none of them answered, <em>“What should I do next?”</em></p><p>The user was always lost. Not because the system was broken. Because it wasn’t telling a story.</p><p>As Don Norman, the father of user-centred design, puts it: <em>“Good design is actually a lot harder to notice than poor design, in part because good designs fit our needs so well that the design is invisible.”</em></p><p>Our system was visible in all the wrong ways. Every click required a decision. Every module demanded orientation. The cognitive load was invisible to us because we had built it — but it was crushing to everyone else.</p><h3><strong>The Work</strong></h3><p>I took it upon myself. No one asked me to. The stakeholders had already signed off and moved on. But I pulled in another designer, and we sat with it for days.</p><p>The question we kept asking was: how do you make something genuinely complicated feel simple without removing what makes it powerful?</p><p>The answer didn’t come from adding anything. It came from reframing everything.</p><p>I knew about storytelling in UX long before this project. But it took building something this complex to truly feel what it meant in practice.</p><p>We stopped asking <em>“What does this module do?”</em> and started asking <em>“What is this module saying?”</em> What is it telling the user about where they are in the process? What story does the system tell from the moment someone logs in until payroll is complete?</p><p>Thirteen modules collapsed into four words: <strong>Setup. Run. Approval. Report.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/367/1*Noqyp_RgpS9L8J5aGANSrw.png" /><figcaption>Four words. That’s the whole story.</figcaption></figure><p>But renaming wasn’t enough. The story needed to be felt at every level.</p><p>We added progress tracking to every module card in Setup — so users could see exactly what they’d configured and what remained.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4OoIW1bSk42tYvAlkiSybQ.png" /><figcaption>Every card tells the user exactly where they stand</figcaption></figure><p>We built a Quick Start Guide that broke the entire setup into nine timed steps, so nobody stared at a blank system wondering where to begin. We made tutorials accessible from within the flow, not buried in a help centre.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/854/1*WGwXCxLU9m1nL4fn-7dlXQ.png" /><figcaption>Nine steps. Timed. No guessing.</figcaption></figure><p>And crucially — if a user tried to run payroll before completing setup, we didn’t block them with an error. We met them there. We showed them their progress, what was done, what wasn’t, and exactly what they needed to finish. The system guided instead of gatekeeping.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r8cwpPecfkZVf-fLOZBuIA.png" /><figcaption>Not a dead end. A redirect with context.</figcaption></figure><p>That’s the difference between a system that works and a system that tells a story.</p><p>When we presented the redesign, every single person in that room followed along — including people who had nothing to do with payroll. No confusion. No silence. Just complete understanding.</p><p>The feedback said everything:</p><p><em>“You’ve built the simplest and easiest product for us. I don’t have to be tense anymore during payroll week.”</em></p><p>Months later, payroll has been running consistently. Not a single support request about how to use it. Sales had one response: “We can’t wait to sell this to more clients.”</p><p>That’s what a story does. It doesn’t just guide the user through a system. It makes them feel like the system was built for them.</p><h3><strong>What This Actually Means</strong></h3><p>Steve Jobs once said, <em>“Design is not just what it looks like and feels like. Design is how it works.”</em></p><p>I’d push that further — design isn’t done until the user understands how it works without being told.</p><p>The payroll system didn’t get simpler. It became clearer. The complexity was still there — every configuration, every pay grade, every approval layer. We didn’t remove any of it. We gave it a narrative.</p><p>That’s the job. Not to make things beautiful. Not even to make them functional. To make them legible. To ensure that anyone who touches what you’ve built understands instinctively what it’s doing, where it’s going, and what they need to do next.</p><p>As Jakob Nielsen emphasises in his usability heuristics, good design reduces cognitive load — it minimises memory effort and shows users what they need, so they can focus on the work, not the tool.</p><p>Your design isn’t done when all the features work. It isn’t done when the UI looks good. It isn’t done when the stakeholders sign off.</p><p>It’s done when the system tells a story so clearly that the user never has to ask, <em>“What’s next?”</em></p><p>Next time you review a design, don’t just ask: Does it work?</p><p>Ask: Does it have a beginning, a middle and an end? Does it guide without instructing? Does it answer questions before the user thinks to ask them?</p><p>If not, you’re not done yet.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a99fad5cd2f" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/your-design-isnt-done-until-it-tells-a-story-4a99fad5cd2f">Your Design Isn’t Done Until It Tells a Story</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Importance of Component-Based Design Systems in Engineering and Design]]></title>
            <link>https://www.designsystemscollective.com/the-importance-of-component-based-design-systems-in-engineering-and-design-43a0e46055fb?source=rss-fc4c2e2910f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/43a0e46055fb</guid>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design]]></category>
            <dc:creator><![CDATA[Christabel Akpoguma]]></dc:creator>
            <pubDate>Thu, 31 Jul 2025 22:14:43 GMT</pubDate>
            <atom:updated>2025-08-02T09:07:32.238Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Why the most successful teams have stopped reinventing the wheel — and started building with Lego blocks instead.</em></h4><figure><img alt="Building block design" src="https://cdn-images-1.medium.com/max/1024/1*f2cUYgAXlDlHxRHkemhvZw.jpeg" /></figure><blockquote>Picture this: It’s 3 PM on a Friday, and your designer just sent over mockups for a new feature. You open the files and immediately spot three different button styles, two conflicting colour schemes, and spacing that doesn’t match anything in your existing codebase. Sound familiar?</blockquote><p>As someone who wears both designer and developer hats, I’ve lived through this frustration from both sides. I’ve been the designer frantically searching through old files for “that shade of blue we used somewhere,” and I’ve been the developer rebuilding the same modal component for the fifth time because nobody documented the first four versions.</p><p>The solution isn’t better communication or more detailed handoffs — it’s fundamentally rethinking how we build digital products. Enter component-based design systems: the shared language that finally gets designers and developers speaking the same dialect.</p><h3>The Real Cost of Design Chaos</h3><p>Before we dive into solutions, let’s acknowledge the problem 😟. Without a design system, every team becomes a collection of individual artisans, each crafting bespoke solutions to problems that have already been solved.</p><p><strong>For designers</strong>, this means:</p><ul><li>Hours spent recreating components that “sort of” exist elsewhere</li><li>Inconsistent user experiences across different product areas</li><li>Design debt that accumulates faster than technical debt</li><li>Endless debates about whether this button should be 8px or 12px rounded</li></ul><p><strong>For developers</strong>, it looks like:</p><ul><li>Copy-pasting code between projects and hoping for the best</li><li>Inconsistent implementations of similar UI patterns</li><li>Painful updates when design decisions change (spoiler: they always do)</li><li>Building the same dropdown menu seven different ways</li></ul><p>But here’s where it gets expensive: these aren’t just workflow inefficiencies. They’re product quality issues that your users feel every day.</p><p>A well-built design system isn’t just a style guide or a collection of React components — it’s a shared source of truth that transforms how teams collaborate.</p><h3>Speed That Actually Matters</h3><p>The most immediate impact? Velocity. When designers can drag and drop battle-tested components instead of designing from scratch, initial mockups happen in hours, not days. When developers can import components instead of building them, features ship faster and with fewer bugs.</p><p>But speed without quality is just rushed work. The real magic happens when speed comes from reusing solutions you’ve already perfected.</p><h3>Dark Mode (and Theme) Flexibility Without the Headaches</h3><p>Here’s a perfect example of why component-based thinking wins: implementing dark mode.</p><p>Without a design system, adding dark mode means touching every single component, screen, and style definition in your codebase. It’s archaeological work — you’re excavating colour values from forgotten CSS files and praying you don’t break anything.</p><p>With a component-based design system, dark mode becomes a configuration change. Your design tokens define light and dark values, your components consume those tokens, and switching themes happens at the system level. One toggle, infinite possibilities.</p><p>The same principle applies to any theming need: seasonal campaigns, accessibility modes, and white-label customisations. Build the system once, reap the benefits forever.</p><h3>The End of “Reinventing the Wheel” Culture</h3><p>Perhaps the biggest productivity killer in product development is solving the same problem multiple times. How many modal dialogues exist in your codebase? How many different loading states? How many custom dropdown implementations?</p><p>Component-based design systems make reinvention impossible (or at least embarrassing). Need a modal? There’s a component for that. Need a data table? It’s already built, tested, and documented. Need a complex form input? Your design system has you covered.</p><p>This isn’t just about code reuse — it’s about decision reuse. Every component encodes dozens of micro-decisions about behaviour, accessibility, and user experience. When teams reuse components, they’re also reusing the thinking that went into those decisions.</p><h3>Consistency That Scales</h3><p>As products grow, maintaining visual and interaction consistency becomes exponentially harder. Without a design system, consistency relies on individual memory and discipline — a strategy that breaks down the moment your team grows beyond a few people.</p><p>Component-based design systems make consistency automatic. Use the system’s button component, and you automatically get the right colours, spacing, typography, hover states, focus indicators, and accessibility attributes. Consistency becomes a byproduct of using the system, not something teams have to consciously maintain.</p><h3>The Designer-Developer Collaboration Revolution</h3><p>This is where the magic really happens. Design systems don’t just improve individual workflows — they transform the relationship between design and development.</p><p><strong>Shared vocabulary</strong>: Instead of describing a “big blue button with rounded corners,” designers and developers can reference the “primary CTA component.” The conversation shifts from implementation details to user experience decisions.</p><p><strong>Parallel workflows</strong>: Designers can prototype with real components while developers build new features with the same components. Design and development happen in parallel, not in sequence.</p><p><strong>Living documentation</strong>: The design system becomes a shared reference that’s always up to date. No more “wait, which button style are we using now?” conversations.</p><p><strong>Faster feedback loops</strong>: When changes happen at the component level, they propagate everywhere instantly. A button style update appears in designs and code simultaneously.</p><h3>The Time Investment Paradox</h3><p>Let’s address the elephant in the room: building a design system takes time 🙄. In an environment where every sprint is packed and every deadline feels urgent, spending weeks building components instead of features can feel like luxury thinking.</p><p>I’ve been in those pressure-cooker moments where product managers are asking for “just a quick modal”, and the last thing you want to explain is why you need three days to build a “simple” component properly. It’s tempting to take shortcuts — copy that button style from the homepage, hardcode those colours, build just enough to ship this feature.</p><p><strong>The short-term reality is brutal</strong>: Design systems require upfront investment when you’re already stretched thin. You’ll spend time documenting components that could have been shipped as one-offs. You’ll have debates about naming conventions when you could be pushing pixels. You’ll build infrastructure that doesn’t directly appear in user-facing features.</p><p><strong>But here’s the math that changes everything</strong>: Every shortcut you take today becomes technical and design debt tomorrow. That “quick modal” you built in two hours? You’ll spend four hours adapting it for the next feature, six hours debugging the accessibility issues you skipped, and eight hours rebuilding it when the design requirements evolve.</p><p>Meanwhile, that three-day investment in a proper modal component pays dividends for years. Every subsequent modal takes fifteen minutes to implement. Every update happens system-wide. Every accessibility improvement propagates automatically.</p><h3>The Constraint Reality Check</h3><p>Time isn’t the only constraint working against design systems. Resource limitations, shifting priorities, and stakeholder pressure all create resistance to systematic thinking.</p><p><strong>Budget constraints</strong> make it hard to justify “building infrastructure” when you could be “building features.” <strong>Team constraints</strong> mean your best designers and developers are already overloaded with immediate needs. <strong>Business constraints</strong> create pressure to show visible progress quarter over quarter.</p><p>These constraints are real, and they affect every team. But the teams that succeed long-term are the ones that recognise a fundamental truth: <strong>constraints don’t disappear — they compound</strong>.</p><p>Building without a system doesn’t eliminate design and development overhead; it just distributes that overhead across every future project. You’ll pay the design system tax eventually — either as an intentional upfront investment or as an ongoing productivity drain.</p><h3>Building Systems That Actually Work</h3><p>The key to a successful design system isn’t the technology — it’s the philosophy. The best systems start small and grow organically based on real needs, especially when working within tight constraints.</p><p>Start with your most common patterns: buttons, form inputs, and layout grids. Build components that solve real problems your team faces today, not theoretical problems you might face tomorrow.</p><p>Document not just what components do, but when and why to use them. Include code examples, design guidelines, and accessibility considerations. Make the system easy to adopt and hard to misuse.</p><p>Most importantly, treat your design system as a product with real users (your team) and evolving requirements. Plan for maintenance, gather feedback, and iterate based on how people actually use the system.</p><h3>The Compound Effect: Why Long-Term Thinking Wins</h3><p>The real power of component-based design systems isn’t visible in week one — it’s the compound effect over months and years. Every component you build once saves hours of work every time it’s reused. Every decision you encode in the system prevents countless future debates. Every consistency improvement enhances the user experience across your entire product.</p><p><strong>Here’s the timeline reality</strong>: Month one feels expensive. You’re building infrastructure while competitors ship features. Month six feels like breaking even. Your team is moving faster, but the initial investment still stings. Month twelve feels transformative. You’re shipping features in days that used to take weeks, and your competitors are drowning in their own technical debt.</p><p>By year two, teams with mature design systems are operating in a different league entirely. They ship features faster, maintain higher quality standards, and spend more time solving user problems instead of rebuilding interface elements. They have the luxury of focusing on what makes their product unique instead of re-implementing the basics.</p><p><strong>The constraint paradox resolves itself</strong>: The time pressure that made design systems feel impossible becomes the exact reason you need them. The resource limitations that made systematic thinking feel expensive become the reason systematic thinking is essential. The business pressure that demanded immediate results becomes satisfied by the sustainable speed that only comes from good systems.</p><p>In a world where digital products are increasingly complex and user expectations are constantly rising, component-based design systems aren’t just a nice-to-have — they’re table stakes for teams that want to build exceptional experiences at scale.</p><p>The question isn’t whether your team needs a design system. The question is whether you can afford to keep building without one. The constraints you feel today will either be solved by intentional system investment or compounded by continued ad-hoc development.</p><p><strong>Time will pass either way. The only choice is whether you spend it building systems or rebuilding solutions.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43a0e46055fb" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/the-importance-of-component-based-design-systems-in-engineering-and-design-43a0e46055fb">The Importance of Component-Based Design Systems in Engineering and Design</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>