There's a design principle in the best SaaS products that rarely gets articulated explicitly: the product defines what's fixed, and users fill in what's flexible.

You see it in the tools that have aged well. Notion lets you define page structure, but users decide how they organize their workspace. Linear gives you issue states, but teams configure the workflow. GitHub sets the code review model, but teams decide their own branch policies.

None of these products try to do everything. They define a shape and let users work within it.

Dashboard products — and especially custom-built dashboards — usually miss this. They ship a fixed view that fits no one perfectly, or they ship "unlimited customization" that collapses under its own complexity. There's a better path.

What 80/20 looks like in practice

The 80% you build:

The data model and what's available to display
The columns, metrics, and filters that make sense for this product
The rules: what's required, what's optional, what's off limits
The performance and multi-tenant guarantees

The 20% users shape:

Which optional columns they want visible
Their preferred sort order and default filters
The layout that fits their workflow

Users don't need to shape the data model. They don't need to define what's available. They just need to adjust the view to fit how they actually work.

This sounds obvious. The reason it's not the default is that most developers conflate "configurable" with "flexible." They're not the same.

Why "configurable" isn't the same as "flexible"

A configurable dashboard gives users knobs to turn. A flexible dashboard lets users define what the knobs do.

The first is manageable. The second is a platform.

Most teams who try to build "flexible" dashboards end up with one of two outcomes:

Outcome A: The configuration UI becomes its own product. Weeks of work building a drag-and-drop layout editor, a column visibility manager, a filter builder. When you're done, you've built a secondary product that competes with your primary product for attention.

Outcome B: The configuration system becomes a source of bugs. Users configure themselves into broken states. Support gets calls about "the dashboard looks wrong." Developers spend time debugging configurations they didn't write.

The 80/20 model avoids both by keeping the flexibility bounded. You define the shape space. Users fill it in. You never let users step outside the bounds, because the bounds are enforced in the code, not by user discipline.

The implementation gap

Here's why developers don't build this by default: the tools for enforcing shape constraints don't exist as a package.

You can find UI libraries for table configuration. You can find state management solutions for storing preferences. What you can't find out of the box is:

A way to declare "this column is shapeable, this one is fixed" in your data model
Multi-tenant preference storage that scopes to user, role, and tenant with the right inheritance rules
Constraint enforcement that prevents users from stepping outside the defined shape space
A reshape panel that your users can actually use without documentation

This is the gap ShapeKit fills. You define the shapeable skill — the declaration of what's fixed and what's optional. ShapeKit handles the rest: the storage, the constraints, the user-facing reshape panel, the multi-tenant scoping.

The developer experience

Without this model, building user-configurable dashboards requires writing the same infrastructure code every time. Schema for user preferences. Authorization logic for who can configure what. Frontend components for the configuration UI. Sync logic for when the underlying data model changes.

You're not building a dashboard. You're building a customization platform on top of your dashboard.

With a constrained shaping model, you declare what's shapeable and ship. Users see a configuration panel that reflects exactly what you've made available. They can't break anything you haven't already approved as breakable.

Build 80%. Let users shape the last 20%.

ShapeKit launches April 15 — full product, no waitlist. Sign up for early access.

Coming soon: The Crafter/Shaper model — why we split the dashboard role in two (publishing April 7).