Lead & Founding Product Designer · 10+ years · B2B SaaS · AI

Paul Emil
Johnson.

I craft enterprise product experiences at the intersection of technology, design, and business. Currently founding designer at Zenskar. Previously Head of Product Design at CogniCor — where I led the design that closed a $1M ARR deal and got our studio acqui-hired.

Open to senior & founding-stage design conversations — 2025

"I work with entrepreneurs and technology teams to co-build products — from conception of an idea to market readiness."

Selected work

  • Zenskar — Billing & Subscription Platform

    Redesigning how usage-based SaaS companies manage pricing, contracts and invoices at scale.

    B2B SaaSFintech2024
  • CogniCor — Enterprise Digital Assistant Platform

    0→1 no-code conversational AI platform. 3 months. $1M ARR. Studio acqui-hired.

    Conversational AIWealth Mgmt2021
  • Awesome Daddies Interactive — Studio

    Founded and led a 15-person product design studio for 4 years.

    FoundingStudio2014–18

Writing

The first 90 days as a founding designer at a B2B AI startup

May 2025 · 8 min

Why your Series A doesn't need a design system yet

Mar 2025 · 6 min

The human-in-the-loop: when to let an AI agent run

Jan 2025 · 5 min

All writing →

Now

Building at Zenskar — billing UX for AI-native quote-to-cash. Pushing Figma and Claude into every corner of my workflow.

Podcasting — "Behind The Screens," real stories from B2B SaaS designers.

Life — expecting our third child. Kerala, India.

Updated May 2025

Work

Selected case studies.

10+ years. Three founding-stage engagements. Fintech, conversational AI, and B2B SaaS.

Zenskar — Billing & Subscription Platform

Redesigned end-to-end UX for usage-based billing SaaS. Conceptual model first, then four product modules. Two-mode edit panel that adapts to complexity automatically.

2024 – present

Lead / Founding Designer

B2B SaaSFintech

CogniCor — Enterprise Digital Assistant Platform

Led 10-person team to ship no-code conversational AI platform in 3 months. Knowledge Base, Document Ingestion, Workflow Builder. $1M ARR. Studio acqui-hired.

2018 – 2024

Head of Product Design

Conversational AIWealth Mgmt

Awesome Daddies Interactive — Design Studio

Founded and scaled a 15-person product design studio. Fintech, retail banking, B2B SaaS, consumer apps across India, Denmark, USA.

2014 – 2018

Founder & Lead Designer

StudioFounding
← all work

Contents

01Context
02The users
034 challenges
04Conceptual model
05Products
06Add Price
07Contracts
08Contract timeline
09Edit panel
10Invoice preview
11Outcome
B2B SaaS · Fintech · Billing2024 – present

Zenskar — making complex billing legible

Zenskar is an end-to-end billing and revenue recognition system for usage-based SaaS. I joined as founding designer and redesigned the entire product experience — from empty states to a two-mode edit panel that adapts to contract complexity in real time.

Role

Lead / Founding Designer

Team

2 designers, engineering

Domain

Billing & Subscription SaaS

Competitors

Stripe Billing, Zuora, Chargebee

Sales-led growth with a product that wasn't keeping up

Zenskar's growth was sales-led, with about 40 demos happening every week. The sales team tagged the design team for qualified prospects — which meant we were learning directly from potential customers what was working and what wasn't. Each enterprise customer had their own dedicated Slack channel for feedback and communication.

The problem was structural: pilot users received sandbox access with dummy data and then were largely left to figure it out. Usability issues were stacking up, new customer requirements kept coming in, and the roadmap had ambitious features that couldn't land without a better foundation.

My job was to find the patterns beneath the noise and redesign the product around the user's actual mental model — not the system's internal data model.

Two very different people, one product

Zenskar's key users are sales representatives and accountants at companies selling usage-based services. A classic example: an API company charging $0.1/minute for video calls. The sales rep sets up the deal, the accountant verifies the invoices.

Sales rep

Owns the customer relationship. Sets up products, creates contracts, negotiates pricing. Needs speed and clarity. Doesn't understand billing mechanics deeply but knows their customers' contracts inside out.

Accountant

Owns invoice accuracy. Verifies billing, approves invoices before they go to customers. Needs confidence that the system reflects reality. Highly sensitive to errors or ambiguity in numbers.

Both users share one primary goal: automatically generate correct invoices at scale. Everything else — products, prices, contracts, metering — is a means to that end. This framing became the north star for every design decision.

Four structural problems blocking the primary goal

Challenge 01

Documentation dependency

Pilot users got sandbox access with dummy data but spent hours in documentation before touching the product. Many lost interest before creating their first invoice. The product wasn't self-explanatory.

Challenge 02

No product reusability

The same product — say, a video call API — might be sold at $0.1/min to one customer and $0.2/min to another. But there was no way to reuse a product with different pricing. Users duplicated products instead, creating a mess.

Challenge 03

Contracts as a black box

Contracts could get complex — varying billing cycles, post-paid vs pre-paid terms, product bundling. But the system gave no feedback while building. Users couldn't see what invoices would look like until after publishing.

Challenge 04

Flexibility vs. complexity

The advanced price editor — a data flow diagram — was powerful but nearly unusable for non-engineers. Only the internal team used it. Flexibility existed but was locked away from the people who needed it.

Before any screens: map the mental model

Most of the confusion came from a mismatch between how users thought about billing and how Zenskar's system actually worked. Before touching Figma, I built a conceptual model of billing from the user's perspective and validated it with the engineering team.

The model is simple: Products contain Prices. Prices go into Contracts. Contracts generate Invoices. This four-step chain had to be visible and legible throughout the product — not hidden in navigation or documentation.

Conceptual model — billing Designed in Figma
01
Products
+ Prices
02
Contracts
+ Terms
03
Publish
Go live
Goal ✓
Invoices
Auto-generated

This model was communicated to users throughout the product — in empty states, onboarding flows, and navigation. The goal was that within 10 minutes of first use, a new pilot user could articulate how the system worked without reading a single doc.

Empty states that teach, not just prompt

The first thing a new user sees is an empty product list. This was redesigned from a blank page with a "Create Product" button into an educational moment — explaining what a product is, what it's used for, and linking to docs — all before the user needs to do anything.

Product listing — empty state (first-time user) Redesigned
Dashboard Products Contracts Invoices Metering
Products
Services and items you sell to customers
+ Create product
📦
No products yet
A product is any service or item you sell to your customers as part of a contract. Create one price or many — reuse across contracts.
Create your first product
View docs ↗
Explains the concept before asking the user to act — reduces the need for external documentation
Two CTAs — create immediately or read docs first. Respects both learner types

The "Prices within Products" insight

The most important design decision in this module came from observing real user behaviour: people were creating duplicate products just to have different pricing for different customers. A video call API sold at $0.1/min to one customer, $0.2/min to another — two separate products in the system.

Before — duplicate products

Video Call API (Standard) → $0.1/min
Video Call API (Premium) → $0.2/min
Two products. Same underlying service. Impossible to manage at scale.

After — prices within a product

Video Call API
↳ Price: Standard → $0.1/min
↳ Price: Premium → $0.2/min
One product, multiple pricing instances. Reuse without duplication.

Create product — with prices concept Core redesign
ProductsContractsInvoices
Product details
Product name
Description
Type
Prices Add multiple prices for different customers or contracts
Standard$0.10 / min · Monthly
Active
Enterprise$0.07 / min · Quarterly
Draft
+ Add price
Preview
Selected price: Standard
Rate: $0.10 / minute
Billing: Monthly
Cycle: Calendar month

Taming pricing complexity without hiding it

Pricing in usage-based billing can get complex fast: flat fee, per-unit, tiered, volume, matrix. Combined with billing cycles, free credits, discounts, minimum commitments, and taxes — the configuration space is enormous.

The design challenge: show all of this without overwhelming a user who just wants a simple monthly fee. Three principles guided the solution.

Principle 01

Group, don't list

Data inputs are grouped by meaning (rate, billing, discounts) rather than presented as one long scrollable form. Users can focus on one thing at a time.

Principle 02

Always-accessible tour

First-time users get a guided tour. The info icon makes it re-accessible anytime — no need to leave the screen or open a doc.

Principle 03

Real-time output preview

As config data is entered, the right panel shows a live invoice preview. Users see the output of their decisions before they commit.

Principle 04

Metering bridge

Usage-based products need metering setup. The price creation flow becomes an introduction to the Metering module — so users understand the dependency before being surprised by it.

Add Price — grouped form with live preview Key redesign
Pricing modelⓘ Quick tour
Flat fee
Per unit
Tiered
Volume
Amount
USD
Billing cadence
Billing cycle
Payment type
+ Free credits + Discount + Min. commitment
Invoice preview
Sample invoice
Video Call API × 1,000 min$100.00
Total$100.00
Updates as you configure. Based on 1,000 units.

Redefining what "contract" means in this context

A contract in the legal sense is a broad document. In Zenskar, "contract" has a more specific meaning: the subset of agreement data related to usage, pricing models, and billing terms. This distinction had to be made explicit in the UI — otherwise users conflated it with their actual legal contracts and got confused about what to enter.

The contract creation flow guides users through: selecting a customer, choosing a billing period, adding products (with their chosen prices), and setting payment terms. First-time users get a quick tour of the summary page.

Contract summary — first-time user tour active Onboarding layer
ProductsContractsInvoices
Acme Corp — Q1 2024
Contract · Jan 1 – Mar 31 · Post-paid · Monthly billing
Edit
Publish contract
Products in this contract
Standard · $0.10/min · Monthly
Active
Flat fee · $500/mo · Monthly
Active
+ Add product
Contract terms
CustomerAcme Corp
PeriodJan 1 – Mar 31
PaymentPost-paid
CurrencyUSD

The feedback loop that was completely missing

The biggest single pain point: users couldn't see what a contract would produce until after they published it. They'd build a complex contract with multiple products and billing periods, hit publish — and then discover the invoices looked nothing like they expected.

"The billing cadence is finally something I can show to a customer without needing to explain what everything means first." — Enterprise customer, via Slack

Once products are added to a contract, a live timeline generates automatically showing exactly when invoices will be created and what amounts they'll contain. For metered products, it shows projected amounts based on current usage data. For non-metered, the amount is exact.

Contract timeline — live invoice preview while building Key innovation
Invoice timeline · Jan 2024 – Mar 2024
Auto-generated based on products and billing cadence. Updates in real time.
Jan 31
Invoice #1
Video API: ~$340
Platform fee: $500
Est. $840
Upcoming
Feb 29
Invoice #2
Video API: ~$340
Platform fee: $500
Est. $840
Upcoming
Mar 31
Invoice #3
Video API: ~$340
Platform fee: $500
Est. $840
Upcoming
~ Metered amounts are estimates based on current billing period data. Non-metered amounts are exact.

Simple by default, advanced when needed

The core tension: most products are simple — one price, one billing cadence. But some customers need mid-contract changes: a price bump in Q3, a billing shift from monthly to quarterly, a discount that only applies for the first 6 months. The old system had no clean way to handle this without creating separate line items or manual overrides.

I designed a two-mode panel. The key insight: the mode switch doesn't need a toggle. It's automatic and data-driven.

Simple mode — default (~80% of cases)

One price, one quantity, one billing cadence spanning the full product period. No timelines, no version management. The form stays flat and scannable. You configure what you need and move on.

Advanced mode — activates automatically

The moment any attribute gets a second version, the layout shifts to an accordion with per-section timelines, version selection, and scheduling controls. Add a second version → advanced. Delete it → back to simple. No toggle. No settings.

Edit product panel — advanced mode (2 price versions) Auto-activates
Video Call API — Edit product
Price 2 versions ▾
Jan–Jun: $0.10/min
Jul–Dec: $0.08/min
+ version
Rate (Jan–Jun)
Billing cadence 1 version ▸
Timeline view
How price versions align with billing
Jan–Jun
$0.10
Jul–Dec
$0.08
Price change highlighted in invoice preview automatically.

Seeing the output before you commit

The final major design was the non-linear invoice preview — a reactive, card-based layout showing each future invoice as it will appear to the customer. Each card shows invoice date, amount, service period, and an editable quantity field for metered products.

The preview is fully reactive to configuration changes: amounts recalculate when price, model, tiers, billing cadence, or quantity change. Price changes and model changes are explicitly called out inline so users can see exactly what changed.

Non-linear invoice preview — reactive to config Prototype built
Invoice preview Recalculates as you change price config
Jan 31, 2024 · Jan 1–31
$940.00
Video API$440
Qty:
Platform fee$500
Upcoming
Feb 29, 2024 · Feb 1–29
$940.00
Video API$440
Platform fee$500
Upcoming
Mar 31, 2024 · Mar 1–31
$940.00
Video API$440
Platform fee$500
Upcoming

Phased release, strong signal

The new design was released to existing customers in phases. The feedback was excellent and two major insights immediately shaped the next release cycle:

Insight 01

Financial relationship view

Users want to see their full financial relationship with each customer across all contracts — not just the current one. A customer-level revenue view is now in the roadmap.

Insight 02

Collaborative editing

Multiple users working on the same contract were missing each other's changes. A collaboration layer with change tracking is planned for the next phase.

↓ signif.

Pilot drop-off and documentation dependency

40/wk

Weekly demos now supported by a self-explanatory product

Ongoing

Phased release with excellent customer feedback

"The billing cadence is finally something I can show to a customer without needing to explain what everything means first."

— Enterprise customer feedback via dedicated Slack channel

← All workCogniCor →
← all work

Contents

01The bet
02My role
03Phase 1: Understand
04SME interviews
05Persona
06Phase 2: Define
07Knowledge base
08Doc ingestion
09Workflow builder
10$1M ARR
Conversational AI · Wealth Mgmt · 0→12018 – 2024

CogniCor — a $1M ARR bet on design

I led a 10-person design and development team from my studio to design and ship a no-code enterprise AI platform in 3 months. The beta closed a $1M ARR deal with one of the largest US wealth management firms. The entire studio was acqui-hired.

Role

Head of Product Design

Team

10 designers + developers

Timeline

3 months to beta

Outcome

$1M ARR · Studio acqui-hired

Stop selling products. Start selling a platform.

CogniCor's early business model was services: they built custom conversational AI agents for enterprise clients in wealth management and insurance. LPL Financial, Ameriprise, BNY Pershing — big names, but an unscalable model. Every new client needed a large team, months of work, and custom engineering for each project.

As they added clients, four structural problems became unmistakeable:

Problem 01

Cost of scalability

Each project needed a large team to develop and maintain it. Though many artefacts and code could be reused, there was no system for it — so projects took many months each time.

Problem 02

Lack of customer participation

Enterprise customers had to depend on CogniCor for any changes or additions to the digital assistant. No transparency. High turnaround time. Customers had data but couldn't control it themselves.

Problem 03

Scattered toolchain

The team used multiple disconnected tools to build different modules — GATE, JAPE, PROTEGE, ECLIPSE. Purely technical. Impossible to use without engineering expertise. Difficult to manage or hand off.

Problem 04

Market pressure

Conversational AI was evolving fast and competitors were rising — offering customer-facing tools to create chatbots. Though technically nascent, they were eroding CogniCor's positioning.

The strategic decision: build a proprietary no-code platform that lets enterprise Knowledge Engineers launch intelligent digital assistants in weeks — without writing a single line of code. No more CogniCor selling DAs; a platform for customers to create and maintain their own.

"The platform had been pitched to a large enterprise client before it existed. We needed to create it in 3 months. The design had to be good enough to close a $1M ARR deal."

Head of experience, from research to front-end

My responsibility was to head the experience of the platform end-to-end: from the research phase through experience design to front-end development. I managed a team of 10 from my design studio — designers and developers — to launch the first version in 3 months and subsequent versions thereafter.

Challenge 01

Strict timelines, huge business stakes

The idea of the platform had already been pitched to a major enterprise client. We needed to create it to the delight of the customer in exactly 3 months — which would help CogniCor win a contract of $1M in ARR.

Challenge 02

Design the DA experience before the platform

The platform is used by enterprises to create DAs for their end customers. We had to first think deeply about the virtual assistant experience — what it would feel like to interact with — before designing the tools to build it.

The existing tools were pure engineering artefacts

I started with system walkthroughs with the engineering team to understand the current tools used to build the digital assistant, how the system worked, and what the core modules were. What I found was sobering.

Multiple tools — GATE, JAPE, PROTEGE, ECLIPSE — were used for knowledge creation, natural language processing, rule creation, and training. It was an essentially technical process: without deep technical knowledge, no part of it was accessible. Interconnected data was spread across different files. Changing a single training variation required touching at least four separate files.

Existing engineering toolchain — before the platform Research artefact
Tool stack (pre-platform)
GATE
NLP processing
JAPE
Rule creation
PROTEGE
Knowledge graph
ECLIPSE
Training
Disconnected. File-based. 4+ files to change one training variation. Engineers only.
CogniCor platform (target)
Knowledge
Single-page tree, document ingestion
Workflow
Visual canvas, triggers + actions
Train · Test · Launch
Guided, no-code, self-service
One platform. GUI-first. No code required. Customer-operated.

CogniCor's real differentiator: knowledge, not intents

Interviews with the founders and subject matter experts revealed the key technological differentiator. Most competitors started with intents — predefined question patterns the chatbot would respond to. CogniCor used a knowledge graph: structured enterprise knowledge where Concepts had Properties with Values.

A simple example: the Concept "Audi Q5" has Properties like Colour, Price, Engine Capacity. Each has Values (red, $45k, 2L). If a user asks "what's the engine capacity of the Audi Q5?", the system finds the Concept, maps to the Property, and returns the Value. This approach scales to handle complex wealth management scenarios and huge datasets in ways intent-based systems cannot.

I also evaluated 9 competitors for UX and key differentiators. Major findings: drag-and-drop tools, pre-built templates, and attractive dashboards were table-stakes. The gap CogniCor could win on was knowledge management depth and enterprise data integration.

Ebna — the Knowledge Engineer

Each DA project is a co-creation with the customer. After understanding requirements, CogniCor trains a set of users at the client organisation and assists them in building and maintaining the project. We called this user a Knowledge Engineer.

EB
Ebna, 28
Digital Innovations team · Top US wealth management firm

Assigned as lead to create the DA using the CogniCor platform as part of a digital transformation of the service centre. Good understanding of business use cases from the Service centre team. Good domain knowledge and language proficiency. Works with a lot of data.

Goals
Create a successful DA for customer service agents. Reduce manual training time by making the DA a companion for agents.
Pain points
Enterprise knowledge is spread across 1,000s of documents. Starting from scratch for every project is extremely time-consuming.

Ebna needed: automation where possible, collaborative editing, quick test-and-debug cycles, version management, and a no-code or low-code solution. She was the person who had to use this platform every day — and if it required engineering knowledge, she'd be stuck.

6 key features, driven by customer impact

After synthesising all research, interviews, and workshop data, I ran several brainstorming sessions with stakeholders to arrive at 6 key platform features — strictly prioritised by impact on customers:

01

Interactive GUI

02

Pre-built templates

03

Doc ingestion

04

Team collaboration

05

Build workflows

06

Knowledge mgmt

In the interest of the 3-month timeline, we focused the beta on two modules: Knowledge and Workflow — the most critical for the enterprise client's use case. Everything else was scheduled for subsequent releases with a compelling roadmap.

The macro user journey we designed: Create or import knowledge → Train → Test → Launch → Analyse. Knowledge was the hard one. If we could get that right, the rest would follow.

One rename that changed everything: Knowledge Graph → Knowledge Base

The first decision was naming. "Knowledge Graph" was the engineering term. "Concepts" was the engineering abstraction. For a Knowledge Engineer like Ebna, these words carried no meaning — or worse, the wrong meaning.

We renamed "Knowledge Graph" to Knowledge Base and "Concepts" to Topics. A simple change, but it shifted the mental model from a technical artefact to something domain experts already worked with every day.

Topics are represented as a hierarchical tree. The critical design insight: everything should happen on a single page. All sub-tasks — adding features, mapping documents, creating sub-topics — happen in panels that open within the context of the tree, not in new pages. Users always maintain awareness of the full knowledge structure while doing focused work.

Knowledge base — single-page tree, right-panel model Core module
Knowledge Workflow Train Test Launch
Knowledge Base
📁 Wealth Management
📂 Products
→ Mutual Funds
→ ETFs ←selected
→ Bonds
📂 Compliance
📂 Client Services
+ Topic
+ Sub
ETFs Wealth Management → Products
Features (4)
Definition: A basket of securities
Min. investment: $1 (fractional)
Risk level: Varies by type
+ Add feature
Documents (2)
📄 ETF_Overview.pdf📄 ETF_Compliance.docx
Tree always visible — no navigation away from the master view when doing sub-tasks. Spatial orientation maintained throughout.
Right panel opens in context — topic selected → details appear right. Drag to reorder topics replaces the old "move topic" button.
Contextual guidance — enough information on each screen to carry out tasks without training. Not overwhelming; just enough.
Topic→Feature→Document links are shown inline — critical for Knowledge Engineers to trace where information came from.

The biggest pain: 1,000s of documents, no way to load them

The greatest pain point Ebna and every Knowledge Engineer faced: enterprise knowledge was spread across thousands of PDFs, Word docs, PowerPoints, user manuals — and there was no way to get it into the platform without manual re-entry. Starting from scratch for every project was extraordinarily time-consuming.

I worked closely with the R&D team — who were simultaneously building the NLP annotation capability — to design a two-mode document ingestion tool. The key question we had to answer first: can this be fully automated?

The answer was nuanced. Full automation had accuracy risks that varied with document quality. But semi-automation was viable: the system could annotate titles as Features and paragraphs as Values automatically, then let the Knowledge Engineer verify, correct, and ingest. Two modes emerged:

Phase 1 — Manual annotation

User uploads document → draws and annotates content by selecting regions → maps selected content to Knowledge Graph objects (Properties/Values) → ingests. Full control, higher effort.

Phase 2 — Semi-automatic

User uploads document → system automatically annotates titles as Features, paragraphs as Values → user inspects recommendations, accepts/rejects/modifies → ingests. Dramatically faster with human verification.

Document ingestion — semi-automatic annotation mode Phase 2
ETF_Overview.pdf — Page 2 of 8 Manual mode
FEATURE AUTO-DETECTED
What is an ETF?
VALUE AUTO-DETECTED
An Exchange-Traded Fund (ETF) is a type of investment fund that tracks an index, sector, commodity, or other asset and can be purchased or sold on a stock exchange.
FEATURE AUTO-DETECTED
Minimum investment
ETFs can be purchased for as little as one share, making them accessible to investors of all sizes...
Detected features (3 found)
What is an ETF?Accept
Maps to: ETFs → Definition
Minimum investmentAccept
Maps to: ETFs → Min. investment
Risk levelsReview
Low confidence — verify mapping
Ingest accepted (2)

"The document ingestion feature solved a great pain of our users and the entire experience was handsomely endorsed."

A canvas that stays legible as it grows

Workflows automate business processes within a conversation — passing information between users according to predefined rules. A Knowledge Engineer needed to build these without writing code. Three components:

Trigger

Invokes the flow

Any Feature in the Feature Library. When a user's query matches the feature (and optionally a topic), the workflow fires. Represented as a red block on the canvas.

Action

The assistant's questions

Any message the VA needs to ask to advance the flow. Supports conditional branching — e.g., if age < 18, go to Action A; else go to Action B.

Script

Custom code box

Developers can add custom code for calculations or API connections. An escape hatch for complex cases that GUI alone can't handle.

The key design decision: when a node is selected or created, the canvas splits 60/40 — the flow graph stays visible at 60%, and a configuration panel opens at 40% on the right. This is consistent with the Knowledge Base design and ensures users never lose spatial context while configuring details.

Workflow builder — split-canvas model, action configuration Core module
Knowledge Workflow Train
Drag to connect nodes · Click to configure
TRIGGER
Asset Allocation Query
ACTION ← editing
Ask: Risk tolerance?
↙ Conservative ↘ Aggressive
Show safe funds
Show growth funds
+ Node
Configure action
Message from assistant
What is your risk tolerance? Choose one: Conservative / Moderate / Aggressive
Validate user input
Input type
Branch conditions
If input = ConservativeAction: Show safe funds
If input = AggressiveAction: Show growth funds
+ Add condition

Beta delivered. Deal closed. Studio acqui-hired.

We delivered the beta on time — participating with the client at every stage of design and development. The end result was appreciated and received excellent feedback. With a strong product and compelling roadmap, CogniCor closed a $1M ARR deal with one of the largest wealth management enterprises in the US — serving over 40,000 financial advisors. The immediate use case was Customer Support; Advisor clients were next on the roadmap.

The leadership team was impressed enough with the design and development quality that they acqui-hired the entire studio. All 10 members of my team joined on a 3-year contract. I moved into a leadership role shaping the product roadmap across multiple use cases.

$1M

ARR deal closed with US wealth management firm (40,000+ advisors)

3 months

From blank canvas to beta delivery, on time

10 people

Entire studio acqui-hired on a 3-year contract

What I learned

Go visual, always. When a new feature came up in a stakeholder meeting, a quick prototype cut the decision-making cycle from days to hours. Collective feedback needs something to react to.
Content is design. Wealth management DA responses are far longer than conventional chatbot replies. We had to redesign the knowledge editor to give more real estate for formatting — a gap that only emerged through real usage.
Teach, don't assume. Even trained users needed contextual guidance on each screen. The best onboarding is embedded in the product itself, not in a separate training session.
Naming is strategy. "Knowledge Base" instead of "Knowledge Graph." "Topics" instead of "Concepts." These two changes shifted the entire mental model for non-technical users.

"The platform has moulded and shaped up a lot since the beta version, addressing diverse use-cases and customer needs. This is the tip of the iceberg."

— Paul Emil Johnson, reflecting on the CogniCor platform years later

← ZenskarAll work →

Writing

Ideas on design,
founders & AI.

For Series A founders and senior designers who want to think more like founders. One essay every 4–6 weeks.

The first 90 days as a founding designer at a B2B AI startup

Week-by-week: what to prioritise, what to skip, how to earn trust fast.

For foundersMay 20258 min

Why your Series A doesn't need a design system yet

The case against premature systemisation — and what to build instead.

For foundersMar 20256 min

The human-in-the-loop: when to let an AI agent run

A confidence × reversibility framework for agentic UX.

Agentic UXJan 20255 min

The taste tax: why AI-generated UI kills B2B conversion

v0 and Lovable are everywhere. Here's the hidden cost.

For foundersNov 20247 min

Designing for AI agents that act on your money

Lessons from shipping agentic UX in high-stakes financial products.

Agentic UXSep 20249 min
Photo

Paul Emil Johnson

Lead & Founding Product Designer
B2B SaaS · Conversational AI · Fintech

Contact

paul@paulemiljohnson.com
inpaulemiljohnson
🎙Behind The Screens podcast

"I work with entrepreneurs and technology teams to co-build products — from conception of an idea to market readiness."

10+ years designing enterprise products in fintech, conversational AI, and B2B SaaS. Started my career winning a 99designs contest for a Danish e-commerce company — which turned into my first job in Denmark. Founded Awesome Daddies Interactive in 2014, grew it to 15 people, and was acqui-hired by CogniCor Technologies in 2018.

At CogniCor I became Head of Product Design, building conversational AI for US wealth management enterprises. Currently founding designer at Zenskar, an AI-native billing SaaS backed by Bessemer Venture Partners.

I host the "Behind The Screens" design podcast, was recognised at the Achievers X Awards 2023, and am a LottieFiles Evangelist representing India.

Experience

2024–now

Founding Product Designer

Zenskar · AI-native billing · NYC / India

2018–2024

Head of Product Design

CogniCor Technologies · Spain & USA

2014–2018

Founder & Lead Designer

Awesome Daddies Interactive · India / Denmark

2013

Design Consultant

Socialware A/S · Denmark

2011–12

UI/UX Designer

Eurostores Group A/S · Denmark

Principles

01

Most B2B SaaS products are 70% the same wireframe and 30% taste. I work on the 30%.

02

Speed is a design decision. Shipping something real beats perfecting something hypothetical.

03

Going visual always accelerates decisions. A quick prototype beats a long meeting.

04

Design systems at Series A are often a way to feel productive instead of shipping.

Now

What I'm focused on right now.

Building

At Zenskar — designing billing UX for AI-native quote-to-cash. Complex pricing models, customer hierarchies, multi-currency. Pushing Figma and Claude into every corner of my design workflow.

Podcasting

Behind The Screens — recording new episodes when the kids are asleep. Real stories from product designers in B2B SaaS.

Writing

Working on a long essay on agentic UX patterns — the confidence × reversibility framework I've applied across financial products.

Reading

Thinking in Systems by Donella Meadows. The Design of Everyday Things for the fourth time.

Life

Expecting our third child. Kerala, India. Life is full — which makes the work matter more.

Last updated May 2025

Updated when things actually change. Inspired by Derek Sivers' /now movement.

Writing

Ideas on design,
founders & AI.

I write for Series A founders and senior designers who want to think like founders. One essay every 4–6 weeks, drawn from real projects.

2025

The first 90 days as a founding designer at a B2B AI startup

Week-by-week: what to prioritise, what to skip, how to earn trust fast.

For foundersMay 20258 min

Why your Series A doesn't need a design system yet

The case against premature systemisation — and what to build instead.

For foundersMar 20256 min

The human-in-the-loop: when to let an AI agent run

A confidence × reversibility framework for agentic UX that users actually trust.

Agentic UXJan 20257 min
2024

The taste tax: why AI-generated UI is costing B2B founders

v0 and Lovable are everywhere. Here's the hidden cost founders are paying.

For foundersNov 20247 min

Naming is strategy: what I learned redesigning CogniCor's platform

Two word changes shifted the entire mental model for 40,000 wealth advisors.

CraftSep 20245 min
← writing
For foundersProcess8 min read

The first 90 days as a founding designer at a B2B AI startup

Nobody warns you that the hardest part of being a founding designer isn't the design. It's knowing what to design, in what order, at what fidelity — while the founders are still figuring out what they're building.

I've done this twice. Once at CogniCor Technologies, where I joined before the product existed and had 3 months to design a platform that would close a $1M ARR deal. And again at Zenskar, where as founding designer I had to rebuild the entire product experience while 40 demos a week were happening and enterprise pilots were losing confidence.

The contexts were very different. The pattern was identical.

Founding design roles are a specific category of hard. You're not walking into a mature product org with runbooks and Figma libraries and a head of design who can orient you. You're walking into a team that's moving at the speed of a Series A raise, where the founders have opinions about everything, where the engineers are brilliant and opinionated, and where "ship it fast" is the operating mode.

Here's what I learned — what to do, what to avoid, and the mental model that held it together.

The 90-day structure

The 90-day founding designer framework Paul Emil Johnson, 2025
Days 1–30

Make the problem legible

Don't open Figma. Map the mental models, translate founder assumptions into visual artifacts the team can argue about, and identify the one user who will tell you the truth.

Days 31–60

Ship something real

Not polished. Not complete. Real enough that a customer can react to it. This is your credibility moment with the founders — and with yourself.

Days 61–90

Build for the team you'll become

A decision log, a lean token system, a one-page "this is how we design here" doc. Not a full design system — not yet. But enough that a second designer could join without losing the thread.

Days 1–30: make the problem legible

Here's the mistake I see founding designers make in the first month: they open Figma. They feel pressure to ship, to show velocity, to justify the hire. So they start designing screens before they understand the system.

Don't. Your most valuable contribution in the first 30 days is translation. Take the founder's mental model — scattered across Notion docs, investor decks, and late-night Slack messages — and convert it into something spatial and arguable. A user journey. A system diagram. A conceptual model that shows how the product's nouns relate to each other.

At Zenskar, one of the first things I did was map the billing conceptual model from a user's perspective: Products contain Prices, Prices go into Contracts, Contracts generate Invoices. Four objects. Four relationships. It took four hours to draw and validate with the engineering team. But it became the foundation for every design decision that followed — what to name things, how to sequence the onboarding, what the empty states should explain.

"Your job in the first 30 days isn't to design. It's to make the problem legible to everyone in the room — including yourself."

Find the user who will tell you the truth. In every product, there's one person on the customer side who will be brutally honest about what's broken. Find them in week one. Not through formal interviews — through Slack, through sitting in on a customer onboarding call, through asking the sales team who gives them the hardest time. That person is your compass for the next 90 days.

Days 31–60: ship something real

By week five, you should have shipped something. Not a polished feature. Not a complete flow. Something real enough that a customer can use it and react to it.

This matters because of trust. Founding designers are expensive hires at a stage where every hire has to prove itself. The founders need to see that you can translate insight into output. The engineers need to see that your designs are buildable. The customers need to see that the product is getting better.

The founding designer's triage framework Decision tool

High confidence + Reversible

Ship now

Low risk to change later. Don't overthink it. Good enough beats perfect.

Low confidence + High stakes

Prototype first

Build a clickable test before committing engineering time. Get a customer reaction.

Uncertain + Founder assumption

Debate openly

Don't design around it. Bring it to a team session and make it explicit. This is where future pivots hide.

No customer signal yet

Defer

Ruthlessly deprioritise anything that doesn't serve the three users you actually have right now.

The trap in this period is building what's impressive rather than what's needed. Founders love features. Sales teams love features. You need to be the person who asks: what's the smallest version of this that would tell us if we're right?

Days 61–90: build for the team you'll become

By month three, you should be thinking about your successor — even if you'll be at this company for five years. What would a second designer need to understand to join without losing the thread of what you've built?

This isn't about building a design system. At Series A, a full design system is usually premature — I'll make that case in another essay. But you do need three artefacts:

  • 01
    A decision log. A running document (Notion works, Figma works) that captures the major design decisions you made and why. Not a beautiful record — a searchable one. When a founder asks "why did we design it this way?" six months from now, you need to be able to answer.
  • 02
    A lean token system. Colours, spacing scale, type scale, border radii — documented and applied consistently. Not a full component library. Just the foundation that makes the next 10 screens feel intentional rather than improvised.
  • 03
    A one-page design principles doc. Three to five principles specific to this product, this user, this context. Not "we value simplicity" — that means nothing. "We assume users understand their business but not our system. Every screen must meet them where they are." That means something.

The thing nobody tells you

Founding design is a leadership role disguised as a craft role. You are not just making screens. You are making decisions about what problems matter, which users to prioritise, how much complexity to expose, what to defer. These are business decisions that happen to manifest in pixels.

The founders hired you because they believe design can be a competitive advantage. Your job is to prove them right — not by making things beautiful, but by making things legible, trustworthy, and fast to evolve. Beauty is a consequence of that, not a starting point.

3 monthsFrom blank canvas to beta at CogniCor — the product that closed $1M ARR
4 hrsTo draw the conceptual model that shaped all of Zenskar's product decisions
This pattern held across both founding designer engagements

The one thing to remember

Founding design is not about being the best designer in the room. It's about making everyone else in the room better at making product decisions. That's a completely different skill — and it starts in the first 30 days, before you've drawn a single screen.

← All writing
Next essayWhy your Series A doesn't need a design system yet →
← writing
For foundersSystems6 min read

Why your Series A doesn't need a design system yet

The case against premature systemisation — and what to build instead when you have one designer, ten engineers, and a product that's still figuring out what it wants to be.

There's a conversation that happens at almost every Series A I've been part of. The founding designer (often me) is six weeks in. The product is starting to feel real. Someone — usually a well-intentioned engineer or a new PM — says: "We should build a design system."

Everyone nods. It sounds right. Design systems are what professional product organisations have. They produce consistency and speed. They're what mature teams do.

Here's what they don't tell you: at Series A, building a full design system is usually the right thing to do at the wrong time. It's a way to feel productive while avoiding the harder, messier work of figuring out what your product actually is.

"A design system is a compression of decisions. You can only compress decisions that have already been made. At Series A, most of your decisions haven't been made yet."

What a design system actually is

A design system is a codification of product decisions. It says: we've decided that buttons look like this, that spacing follows this scale, that these are the colours that represent our brand, that error states have this structure. These decisions have been made, tested with users, and are stable enough to systematise.

The problem at Series A: you haven't made most of those decisions yet. You're still learning what your users need. Your core flows are changing every two weeks. The feature that seemed central six months ago might be deprecated next quarter. When you build a design system around decisions that aren't settled, you build debt — components that need to be rearchitected, tokens that need to be renamed, patterns that need to be deprecated.

Design system readiness: when to build what

Series A (1–3 engineers)

What you actually need

Colour tokens · Spacing scale · Type scale · One component per pattern (button, input, card). Written in Notion or a Figma style guide. No Storybook. No documentation site.

Series B (5–15 engineers)

Component library

Figma component library with variants · Basic Storybook · Shared spacing and colour tokens committed to the repo. One person owns it part-time.

Series C (15+ engineers)

Design system team

Dedicated design system designer or team · Contribution model · Usage tracking · Accessibility audit · Documentation site.

The right question at Series A

What prevents inconsistency today?

Usually: colours, type, and spacing. Fix those. Nothing else is worth systematising until your product has stayed stable for 90+ days.

What to build instead

At Series A, you need three things, and only three things, from a systems perspective:

  • 01
    A decision log. This is not a design system. It's a searchable record of why you made the design decisions you made. When the PM asks "why is the contract summary page structured this way?" six months from now, you need to be able to answer. A Notion doc, a Figma page, a GitHub README — whatever your team reads.
  • 02
    A lean token system. Colours, spacing, type scale, border radii. Committed to the codebase as CSS variables or design tokens. Not 400 components — four files. This is the minimum that prevents your product from looking different on every page. Do this in week two and never look back.
  • 03
    A single reusable component per recurring pattern. You have a button. You have a text input. You have a card. Build one version of each, well. Give it states (default, hover, focus, error, disabled). That's it. Resist the urge to build variants for situations that don't exist yet.

The hidden cost of building too early

When Zenskar was still finding its product-market fit, there was a temptation to stabilise the visual layer before the experience layer was settled. We had enterprise customers in dedicated Slack channels giving feedback every day. The product was changing fast.

If we'd built a component library in that period, we would have had to rebuild 60% of it six months later. Every abstracted component becomes a maintenance burden when the underlying design assumption changes. At the pace of a Series A, that's almost every component.

"Every component you build is a promise to maintain it. At Series A, you can only afford promises you're certain you'll keep."

The signal that you're ready

There's one reliable signal that you're ready to invest in a real design system: a second designer has joined and you're spending more than two hours a week explaining "how we do things here." That friction — onboarding friction, inconsistency friction, communication friction — is the cost that a design system actually solves.

Until that cost exists, a design system is a solution to a problem you don't have yet. And at Series A, the most expensive mistake you can make is building solutions to problems you don't have.

The practical rule

Don't build a component until the same pattern has appeared in your product three times and stayed stable for 60 days. Before that, copy-paste and accept the inconsistency. The inconsistency is honest; a component library that needs to be deprecated isn't.

One more thing

Design systems are seductive because they feel productive. Organising components, writing documentation, setting up Storybook — it's satisfying work. It looks like progress. It's measurable. You can show it to the founders and say "look what we built."

But the founding designer's job is not to look busy. It's to reduce the distance between insight and output — for every team in the company. Sometimes that means building infrastructure. Most of the time, at Series A, it means shipping faster with less.

← 90 days as a founding designer
Next essayThe human-in-the-loop →
← writing
Agentic UXAI7 min read

The human-in-the-loop: when to let an AI agent run

AI agents that act on your behalf are everywhere. Billing systems, outreach automation, revenue ops. But when does a human need to be in that loop — and when is the loop itself the problem?

I've designed three products in the last four years where an AI agent performs consequential actions on behalf of a human. A billing platform that generates invoices for thousands of dollars. A revenue automation tool that contacts high-value prospects. A conversational AI that answers questions from 40,000 financial advisors.

All three faced the same design question: where does the human need to be? Not as a philosophical question — as a product question. Which actions require human approval? Which can run fully automatically? Which need a review step, and what should that review look like?

After designing these systems, I have a framework. It's not complicated. It has two dimensions and four quadrants. But before I share it, let me share the failure mode it exists to prevent.

The failure mode: reviewing everything, trusting nothing

The instinct when building agentic systems — in both founders and designers — is to put a human in the loop for everything. Approve every invoice. Review every outreach email. Confirm every recommendation. It feels safe. It feels responsible. It feels like you're not abandoning the user.

But this instinct creates a product that's slower than doing it manually. The agent becomes theatre — it does the work, then makes you do the work again. The user loses trust in the system not because the agent is wrong, but because being asked to approve every decision signals that the system isn't confident. And if the system isn't confident, why is the user using it?

"An approval flow that users rubber-stamp is not a safety mechanism. It's a liability shift. And it teaches users to stop paying attention to the thing that matters."

The opposite failure is equally real: let the agent run everything automatically and watch one wrong action destroy six months of trust. An agent that sends an incorrect invoice to an enterprise customer without human review, or contacts a prospect with wrong information, or recommends the wrong financial product — these are not UX problems. They're business problems.

The confidence × reversibility framework

After thinking through these systems carefully, I've landed on two dimensions that determine where a human needs to be in the loop.

Confidence — how certain is the system that its action is correct? This comes from the quality of the input data, the complexity of the decision, and the track record of the model on this type of task.

Reversibility — if the action is wrong, how hard is it to undo? A sent email is hard to unsend. An approved invoice that's been paid is very hard to reverse. A recommendation that's been ignored is trivially reversible.

The confidence × reversibility framework for agentic UX Paul Emil Johnson, 2025
← Low reversibilityHigh reversibility →

High confidence + Irreversible

⚠ Review with context

Show the agent's work. Give the user everything they need to make a fast, informed decision. One click to approve — not a form.

High confidence + Reversible

✓ Run automatically

Let the agent act. Show what happened in an audit log. Trust earns autonomy. This is where you prove the product's value.

Low confidence + Irreversible

✗ Don't automate

Not everything should be automated. Some decisions require human judgment — and pretending otherwise is a product mistake, not an AI limitation.

Low confidence + Reversible

~ Suggest, don't act

Propose a recommendation. Make it easy to accept or dismiss. Log the outcome to improve future confidence.

↑ High confidenceLow confidence ↓

How this plays out in practice: Zenskar invoicing

At Zenskar, the core product goal is automatic invoice generation. A billing system that generates invoices for enterprise customers with complex pricing models — tiered usage, mid-contract price changes, multiple products per contract.

We applied this framework to every step of the invoice lifecycle:

  • Auto
    Generating upcoming invoices based on billing cadence. High confidence (pure calculation), reversible (upcoming, not yet approved). The system runs automatically, shows upcoming invoices in a list, user can inspect at any time.
  • Review
    Moving invoices from upcoming to draft. At the draft stage, users can edit the quantity for metered products, verify line items, approve, and send. The review is lightweight — one screen, one decision.
  • Human
    First contract for a new customer. The first time a user publishes a contract, we surface a prominent CTA to visit the invoices section. This isn't automated — it's a prompted review moment to build confidence in the system.

Designing the review experience

When a human does need to review an agent's output, the design of that review moment determines whether the loop is a safeguard or a burden. Three principles:

  • 01
    Show the agent's reasoning, not just its output. If a billing system generated an invoice for $2,300 instead of the expected $2,000, show me why. Which line item changed? Which usage metric caused the difference? The review screen should make the delta legible, not just show the final number.
  • 02
    Make approval a one-action decision. If reviewing the agent's output requires opening five tabs, the user will start rubber-stamping. The review moment should surface everything needed for a confident decision in one screen.
  • 03
    Log outcomes to improve confidence over time. Every approval or rejection is a signal. Build a feedback loop that lets the system learn which actions it can handle autonomously and which ones still need a human. This is how the quadrant shifts — actions start in "Suggest" and graduate to "Auto" as confidence builds.

The principle underneath everything

The goal of agentic UX is not to remove humans from decisions. It's to put humans in front of only the decisions that require human judgment — and to make those decisions as fast and well-informed as possible. Everything else is friction the agent should absorb.

Where this is going

As AI models improve, the confidence dimension shifts right across most tasks. Actions that require human review today will be automatable in 18 months. The framework doesn't change — but the position of each task within it does.

The implication for designers: build your review flows to be gracefully degradable. When confidence improves, the review step should be easy to remove without a redesign. The audit log replaces the approval screen. The exception triggers the review, not the rule.

Design for the world where the agent is right 99% of the time — and make the 1% visible, actionable, and fast.

← Design systems at Series A
Next essayThe taste tax →
← writing
For foundersDesign7 min read

The taste tax: why AI-generated UI is costing B2B founders

Tools like v0, Lovable, and Bolt are making it possible to ship a B2B product without a designer. But there's a cost that doesn't show up in your Figma bill — and it shows up six months later, in conversion and retention numbers.

I want to be precise about what I'm arguing here, because the naive version of this argument is wrong and the nuanced version matters.

I'm not saying AI-generated UI is bad. I'm saying there's a hidden cost that most founders haven't priced in — and that cost is paid at the exact moment you can least afford it: when a qualified enterprise prospect opens your product for the first time and forms an opinion in eleven seconds.

I'm calling it the taste tax. Here's what it is, how it accumulates, and when it matters.

What taste actually is in B2B product

Taste, in the context of B2B product design, is not aesthetics. It's not about whether your colours are nice or your typography is elegant. Those things matter, but they're downstream of something more fundamental.

Taste is the quality of decisions about what to show, what to hide, what to name, and where to put things. It's the judgment that says: this piece of information will confuse a first-time user, so it belongs in a tooltip, not in the main view. Or: this workflow has seven steps but only three of them matter to 90% of users, so the other four should be in an advanced mode.

AI-generated UI makes excellent decisions about the surface: the correct colour for a button, an appropriate spacing scale, a sensible component hierarchy. What it cannot do — yet — is make good decisions about the substance: what information a specific user needs at a specific moment in their journey with a specific product.

"Most B2B SaaS products are 70% the same wireframe and 30% taste. The 70% is solved. The 30% is why your users are confused."

Where AI-generated UI excels

Let's be honest about what these tools do well, because dismissing them entirely would be as wrong as over-relying on them.

When to use AI-generated UI vs. human design judgment

AI-generated UI excels at

Structure and scaffold

Generating the standard 80% of any B2B interface: navigation, list views, detail panels, form layouts, data tables. Fast, correct, good enough to test with.

AI-generated UI excels at

Speed to first version

Getting from idea to testable prototype in hours, not days. For founders doing early customer discovery, this is enormously valuable. Don't hire a designer to build what you're throwing away anyway.

Human judgment required

Conceptual model design

Deciding what your product's nouns and verbs are. What a "contract" means in your system vs. in the user's head. The naming decisions that determine whether a new user can orient in 10 minutes or 10 days.

Human judgment required

Progressive disclosure

Deciding what to show a new user vs. an expert user. What belongs in an empty state, what belongs in a tooltip, what belongs in the docs. This is pure judgment — and AI gets it wrong at the margins.

How the taste tax accumulates

The taste tax isn't a single moment. It accumulates across a hundred small decisions that compound over time. Here's the mechanism:

  • 01
    The wrong naming decision. You call it a "Knowledge Graph" because that's what the engineering team calls it. Users call it a database. The mismatch costs you five minutes of every onboarding call for the next two years. At CogniCor, we renamed it to "Knowledge Base" — two words, massive impact.
  • 02
    The missing feedback loop. Users build a complex billing contract but can't see what invoices it will produce until after they publish. Every pilot user hits this and loses confidence. The fix — a live timeline — is not obvious to an AI generating UI from a brief. It requires understanding the user's anxiety about making a mistake.
  • 03
    The empty state that just empties. An AI-generated empty state says "No products yet" with a button to create one. A designed empty state explains what a product is, why you need it, and what happens after you create it. The difference is not visual — it's editorial. It requires knowing what the user doesn't know.

None of these are dramatic failures. None of them will crash your server or cause data loss. They will each add 5–10 minutes to every customer onboarding. They will each increase your support ticket volume by 3–8%. They will each reduce the percentage of pilots that convert to paid by 1–2 percentage points.

And 1–2 points on pilot conversion, compounded across 40 demos a week, over a year, is not a rounding error. It's the difference between a successful Series B and a difficult one.

When the taste tax doesn't matter

I want to be honest about when this argument doesn't apply — because pretending otherwise would be paternalistic.

If you are pre-PMF, doing customer discovery, iterating on positioning — use every AI tool at your disposal. Speed is the only thing that matters. The interface is a vehicle for learning, not a product in itself. Ship, learn, throw away, repeat.

If you are a consumer product where the interface is the product — social, media, entertainment — taste is everything from day one. Get a designer immediately.

If you are a B2B product with 10+ paying customers, a clear ICP, and a product that you're iterating on rather than replacing — this is when the taste tax starts being real. This is when you should hire your first designer, and hire them the way you'd hire your first engineer: not for execution, but for judgment.

The practical rule for founders

Use AI tools to build what you're going to throw away. Hire a designer to build what you're going to keep. The distinction between those two categories is the most important product decision you'll make in year two.

What good taste actually looks like

The irony of the taste tax is that good taste is often invisible. When you experience it, you don't notice it — you just move through the product without friction. The invoice timeline at Zenskar that updates in real time as you configure a contract: users don't notice the design, they just feel confident. The Knowledge Base tree that stays visible while you edit a topic: users don't notice the layout, they just don't get lost.

Taste is the absence of unnecessary confusion. AI can generate interfaces. It takes human judgment to know which parts of the interface are creating confusion that shouldn't be there.

← Human-in-the-loop
Next essayNaming is strategy →
← writing
CraftNaming5 min read

Naming is strategy: what I learned redesigning a conversational AI platform

At CogniCor, two word changes shifted the entire mental model for thousands of enterprise users — and changed the trajectory of a $1M ARR product. Here's the framework I use for naming decisions in complex B2B products.

In 2018, I started designing a no-code platform for enterprise conversational AI at CogniCor Technologies. The platform was used by Knowledge Engineers at large US wealth management firms to build and maintain digital assistants that served tens of thousands of financial advisors.

The engineering team had built the platform on a powerful abstraction called a "Knowledge Graph" — a structured representation of enterprise knowledge where "Concepts" had "Properties" with "Values." It was technically precise and internally meaningful. It was also completely opaque to the Knowledge Engineers who needed to use it every day.

We made two changes that transformed the product: we renamed "Knowledge Graph" to Knowledge Base, and "Concepts" to Topics.

That's it. Two words. And those two words changed the trajectory of a product that eventually closed a $1M ARR deal.

Why naming matters more than you think

Names are not labels. In a complex B2B product, names are the user's primary navigation system for understanding what the product does and how its parts relate to each other.

When a new user opens a product, they bring a mental model built from their work and their language. They know what a "database" is, what a "document" is, what a "category" is. They do not know what a "Knowledge Graph" is unless they have a background in information science.

If the product's language doesn't connect to the user's mental model, two things happen: the user's confidence collapses in the first five minutes, and every subsequent experience is filtered through that initial confusion. They never feel like they belong in the product.

"Names are the user's map of the territory. If the names are wrong, every step they take is in the wrong direction."

The Knowledge Graph → Knowledge Base rename

Let me walk through the actual decision, because the reasoning matters more than the conclusion.

The naming decision — before and after

Before — engineering language

Knowledge Graph

Accurate description of the underlying data structure. Meaningful to graph theorists and NLP engineers. Completely opaque to knowledge domain experts who are not engineers.

After — user language

Knowledge Base

Language every knowledge worker uses every day. "Base" implies structure, without implying a specific data structure. Users understood immediately what it was and what it was for.

Before — engineering abstraction

Concepts

A technical abstraction for a node in the knowledge graph. Abstract, uncommitted, feels like a philosophy seminar. Knowledge Engineers didn't know whether to create one Concept or ten for a product line.

After — domain language

Topics

Language borrowed from the domain experts themselves. A financial advisor knows what "topics" means. Knowledge Engineers immediately understood how to organise their knowledge into Topics without instruction.

The decision wasn't arbitrary. I spent three weeks with Knowledge Engineers, watching them try to use the platform, listening to how they described their own work. They didn't say "I need to create a Concept for mutual funds." They said "I need to add a section on mutual funds." They used words like "topics," "sections," "categories" — words from their professional language, not ours.

The rename was an act of listening, not creativity.

A framework for naming decisions in complex B2B

After that experience, I've developed a set of tests I run for every major naming decision in a B2B product. In order:

  • 01
    Does the user already have a word for this? The best name is the one the user already uses in their professional life. Listen for it in interviews, in support tickets, in the way your sales team explains the product. If they're already saying a word, use it.
  • 02
    Does the name imply the correct action? "Knowledge Base" implies storage and retrieval. "Knowledge Graph" implies a visualisation. The correct implication determined which name to use — not which was more technically accurate.
  • 03
    Is it consistent with adjacent names? At Zenskar, I had to decide: is it a "Price" or a "Pricing Model" or a "Rate Plan"? The right answer was "Price" — because it's the word that sits naturally next to "Product" and "Contract." The three together form a grammatically coherent sentence the user can say out loud.
  • 04
    Can you explain it in one sentence without jargon? If you need two sentences with a dependent clause, the name is probably wrong. "A Topic is the structured representation of a domain entity in your knowledge graph" is a bad name. "Topics are the subjects your digital assistant knows about" is a good one.
  • 05
    Will it survive the product's evolution? Names that are too specific to the current implementation break when the implementation changes. "Knowledge Base" will survive CogniCor adding vector search, multi-modal support, and LLM integration. "Knowledge Graph" became misleading the moment those capabilities were added.

The compounding effect

What made those two renames so impactful was not just the individual clarity they created. It was that they freed up the rest of the design to make sense.

Once users understood what a Topic was, they immediately understood why the interface was organised as a tree. Once they understood the Knowledge Base as a place where knowledge lives, the concept of importing documents into it was intuitive. Once the foundational nouns made sense, the verbs — create, edit, import, publish — were obvious.

Good naming creates a cascade of legibility. Bad naming creates a cascade of confusion that no amount of design polish can fix.

2Word changes that transformed the CogniCor platform's usability
3 wksOf user observation to find the right words — listening, not inventing
$1MARR deal that closed on a platform users could finally navigate on their own

The one thing I'd do differently

We made the rename three months into the project, after we'd already built significant parts of the platform with the old naming. If I could do it again, I'd run the naming exercise in week one — before any screen design, before any engineering work on the interface layer.

Naming is not a design task you do after the wireframes are done. It's a strategy task you do before the wireframes start. Get the names right, and the wireframes design themselves. Get the names wrong, and you're redesigning the wireframes forever.

The rule I now follow

Before designing any new module or feature in a complex B2B product, I spend at least one session just on naming: what are the 3–5 nouns in this feature? What are the 2–3 verbs? Can the user say a sentence that uses all of them naturally? If not, the names are wrong, and no amount of screen design will fix that.

← The taste tax
All writing →