At ConvertKit, we’re building a new design system for our marketing website. And when I say “we,” I mean three people: two designers and one developer, all with other responsibilities and priorities alongside this work.
We don’t have a dedicated design systems team. We need an approach that lets us build a solid foundation while still getting pages designed, developed, and shipped.
We’re very much in the early stages, but we’ve already made some important decisions about how the system should work, how it should connect to our codebase, and how we’ll develop it without disappearing into a huge component-building project. The goal isn’t simply to create a beautifully organized Figma file. It’s to make our everyday work better.
Key Takeaways
- A useful design system connects reusable design components, documentation, and their implementation in code.
- Shared spacing, typography, and responsive foundations help designers and developers work from the same decisions.
- Build components from real page needs rather than designing a speculative library in isolation.
- Review coded components individually so foundational decisions carry consistently across the website.
Start with What the Design System Needs to Solve
Creating a design system takes a lot of time, energy, and focus. Before investing in it, we need to be clear about what we want to get out of it.
For our team, the two biggest goals are alignment and efficiency. Those sound quite broad, so here’s what they mean in practice.
Update components instead of redesigning every page
We regularly get requests to update existing pages on the website. Previously, it was easy to approach each request as another little redesign: reconsider the layout, create something new, and work through how to build it.
With established components, we can start from decisions we’ve already made. That should give us a faster workflow, but it also changes how we think about the work.
Instead of asking only what a particular page needs, we start asking what should happen to the component. Where else does it appear? How will a change affect those other places? Will this still work for the next page we create?
That shift encourages us to plan ahead rather than repeatedly solve the same problem.
Give the team a shared set of decisions
For a long time, I was the only designer thinking about the marketing website. Now that David, our senior marketing designer, and I are working on it together, we need more of those decisions to live somewhere other than in my head.
A shared system gives us the same set of options to work from. It also makes it easier for someone new to join the team and start using established patterns rather than having to uncover them through individual projects.
It can be difficult to make the case for a system when only one person uses it. But teams grow and change. Having that foundation in place helps the work become less dependent on any one person’s memory.
Refine the visual language intentionally
We’re also making changes to our visual design language, so creating the system gives us a useful place to make those decisions together.
It feels a bit like Marie Kondo-ing our design language. Some things are coming with us. Other things we can thank for their service and move on from.
This isn’t about changing everything. It’s about deciding what still works, what needs refining, and what we want to leave behind.
Make development more efficient too
The benefits can’t stop at the design file. Cory, our senior front-end developer, needs reusable components in the codebase that correspond to what we’re using in Figma.
If we know a component will appear across several pages, with a few defined variations, he shouldn’t have to build it from scratch each time. The system should make everyone’s workflow better, not just the designers’.
A Component Library Isn’t the Whole Design System
I created an earlier version of a marketing design system in 2019. Looking back, I’d describe it more accurately as a component library.
It helped me make mockups faster, which was useful. But it didn’t connect to the codebase, and it didn’t have documentation. For what we need now, those are two important missing pieces.
A collection of reusable elements in Figma doesn’t automatically tell the team how those elements should be implemented, how they should behave, or how changes should carry through to the live website.
Our current website rebuild gives us the opportunity to bring those pieces together. We’re changing not only what’s in the design file, but also how the site is built.
Bring Figma and the Codebase into Alignment
From a development perspective, we’ve had two recurring challenges:
- Translating static designs into a website while keeping designers and developers speaking the same language.
- Updating components efficiently, whether the change affects their appearance, functionality, or underlying implementation.
A static design is only one representation of an interface. Cory has to translate that design into something that works in the browser across different devices. A shared understanding of the component makes that translation much easier.
Use reusable components on both sides
For the rebuild, we’re using React components. The basic idea will feel familiar if you use components in Figma: you define something reusable, then use instances of it throughout an interface.
Think of a button or a card. In Figma, you can update the main component and have that change reflected in its instances. We want the same principle in our codebase.
Cory can build a component, give it the appropriate content or data, and render it wherever we need it with the intended design. Rather than repeatedly recreating the same thing, we’re working from one reusable implementation.
Shared styles weren’t enough
On the existing site, we did reuse CSS classes to give elements a consistent appearance. But the underlying HTML wasn’t necessarily the same everywhere.
That meant a change still required checking the individual pages where an element appeared. If we needed to change its structure or behavior, we could end up finding and updating every instance manually.
Our move from Bootstrap to Tailwind is a good example. Without a shared component controlling the markup, changing the styling approach meant going through potentially hundreds of pages or posts to update the classes on those elements. Not a particularly enjoyable task.
With a reusable component, that implementation change can happen in the component itself and carry through to the places that use it. That’s much closer to the way we already expect a Figma component library to work.
How We’re Organizing the Figma Libraries
Our overarching design system is split across three main libraries:
- Shared library: Assets used by both marketing and product designers, including logos, icons, colors, and a developer-notes tool.
- Marketing design system: The foundations and components for the marketing website.
- Product design system: The system used for the app.
We want everyone pulling shared assets from the same place, but we don’t need everything to be identical. Marketing and product use slightly different button styling and typography, so keeping those systems separate makes sense for us.
Within the marketing file, we’re using colored emoji in the page names as a simple progress indicator:
- Green: We’re reasonably happy with the design in Figma.
- Yellow: Work has started and is getting closer.
- Red: There’s still plenty to figure out.
The distinction matters: green doesn’t necessarily mean implemented in code. At this stage, it means we’re happy with where the design has landed.
Build the Foundations Before the Page Components
Before creating a large collection of page sections, we’ve been working through the underlying decisions: spacing, typography, responsive frames, buttons, shadows, and navigation.
Spacing creates a shared language
Spacing was one of the things that first highlighted our need for better alignment between design and development.
Cory is using Tailwind on the site, so we’re using a Tailwind-style spacing system in Figma. I found a useful Tailwind spacing component in the Figma Community that has the spacing units set up as variants.
We can drag that component in from the Assets panel and use it as a spacer in our designs. That makes the intended gap between elements explicit rather than leaving someone to interpret it.
Our base relationship is:
- 1rem: 16 pixels at our default root font size.
- Tailwind spacing unit 4: 1rem.
- Tailwind spacing unit 4.5: 1.125rem, or 18 pixels at that default, which we need for some font sizes.
The naming is an important part of the shared language. When we refer to spacing unit 4, we need to understand the same value, even though Figma and the browser represent it differently.
The scale also gives our layouts a more consistent rhythm. We’re not inventing a new spacing value every time something needs a little more room.
Use relative units thoughtfully
We’re using rem units in the implementation because they’re relative to the root font size. That helps sizing respond to a person’s font-size preferences, which is particularly important for people who need larger text.
The 16-pixel relationship is our default reference, not a guarantee that everyone will experience the interface at that size. If you’re unfamiliar with how relative sizing works, MDN’s guide to CSS values and units explains the distinction.
This foundation informs more than the spaces between sections. We’re also using it to guide typography and corner-radius decisions.
Refine typography without replacing everything
Typography was one of the first things we wanted to settle. We haven’t changed our fonts. Instead, we’ve refined the sizes and made sure they fit the system we’re establishing.
We’ve documented how the typography is set up and created Figma text styles for it. There are separate styles for desktop and mobile, with smaller sizes where appropriate on mobile.
The implementation uses rem units, keeping the typography connected to that relative sizing foundation.
Set up responsive frames with useful defaults
We’ve also created website frames for the screen sizes and breakpoints we design around. They include layout grids, along with notes David added to document the setup.
Our breakpoints differ a little from Tailwind’s defaults. We’re choosing what works for our website rather than treating the framework’s starting values as requirements.
The frames are set up as Figma variants. We can drag in the base mobile frame, choose a larger size if needed, and then detach the instance to use it as the working frame for a design.
It’s a small workflow improvement, but it means we don’t need to rebuild the same setup every time we start a page.
Expect components to take a few attempts
Buttons are set up with different sizes and variants, although getting there took me about three attempts. Sometimes that’s simply how the work goes.
David has also been developing a shadow system with different depths and colors, alongside the navigation. Once those pieces are settled, we’ll have the base in place to move further into page elements.
Another component I’ve made is the callout bubble used around the ConvertKit site. It has variants for different arrow directions and other options. But I’ve already learned some better ways to structure it, so I expect to revisit it.
Apparently, that might be another component I make three times before I’m happy with it. I’m fine with that. We’re learning as we build.
Design Components in the Context of Real Pages
We haven’t jumped straight into creating every possible section we might use on a marketing page. That’s deliberate.
We’re building the system through the pages we actually need to design.
For example, I’m working on a new product overview page. That work is helping us establish the patterns we want to bring into the system, using real copy, real content, and a real layout.
I much prefer that to designing components in isolation. You could spend ages making a lovely carousel, then discover that it doesn’t suit the content your team needs to put in it. Perhaps it doesn’t fit the page where you expected to use it. Or perhaps you don’t need a carousel at all.
Designing in context helps us avoid investing in hypothetical components.
Even a straightforward pattern, such as an H2 with a large paragraph underneath, needs its spacing refined in context. Once that relationship works and we can see that we’ll reuse it, we can build it into a component.
There are lots of ways to approach a design system. For our small team, this one lets the system grow alongside useful work rather than becoming a separate mountain of work we have to climb first.
Review the Implementation at Component Level
There’s one part of our process where we need to move in the opposite direction.
We’re developing the designs in the context of whole pages, but we need to get better at reviewing the implementation of individual components.
Our normal review process has focused on a complete page. Now David, Cory, and I need to check the particular pieces as they’re built, making sure the coded foundations match the decisions in Figma.
If we get those bones right, they’ll be right when we use them across the website. Waiting until a whole page is assembled makes it harder to give those foundational decisions the attention they need.
We’re still figuring out exactly how that collaboration should work. This isn’t a finished system or a perfectly polished process.
Honestly, the sheer amount of work involved has felt overwhelming at times. That’s another reason we’re choosing to build from real pages: it gives us something concrete to focus on.
For us, progress means establishing the foundations, keeping design and code aligned, and turning proven page patterns into reusable components. We don’t need to solve every future possibility at once. We need a system that helps three people do better work together.


