Mike Long

Contract clarity

Schema Template Designer

Turned an ambiguous schema template feature into an implementable contract workflow for authoring, preview, and apply.

Updated Feb 25, 2026

Context
A schema-template feature inside Nexla's NextSet workflow where contract owners and operators needed shared meaning, reusable rules, and faster application.
Role & scope
Product design lead across contract model, apply workflow, authoring-system definition, and implementation-ready interaction decisions.
Outcome
Reframed templates as reusable data contracts and delivered a shippable create -> preview -> apply loop with clearer defaults and less mapping ambiguity.

Artifacts

The visual proof behind the outcome.

Selected frames and diagrams that show the structural decisions, not just the final polish.

Before-state schema template workflow
Before-state workflowThe baseline experience mixed mapped and unmapped states and made apply semantics hard to follow.
Apply templates workflow
Apply templates in NextSetThe interaction model that focused operators on unmapped gaps and made import behavior predictable.
Authoring wireframe with preview
Authoring modelThree authoring inputs feeding one preview so contract owners and operators shared the same model.

Problem

Schema templates existed, but they were not functioning as reusable contracts.

  • Templates captured field names, but meaning and validations still lived in docs
  • Apply behavior was ambiguous at exactly the moment users needed confidence
  • Mapping sessions created rework because selection and import states were unclear

The product had the pieces, but not a coherent contract model that users and engineering could both rely on.

"There's three separate JSON blobs I'm saving."

Engineering and product constraint

Context

This feature sat inside a workflow with two linked users:

  • The template author defining reusable contract logic
  • The operator applying that contract while closing mapping gaps under time pressure

To make the system workable, I simplified the mental model to the smallest set of choices that unlocked end-to-end usage:

  • Contract = shape + validations + annotations
  • Preview should behave like apply
  • Defaults should focus users on unmapped gaps first
  • Guided and JSON modes should write to the same underlying model

Approach

The first major decision was to treat apply as a guided workflow instead of a loose collection of options.

  • Focus operators on unmapped fields first
  • Provide a clear select-all fast path
  • Keep import behavior explicit and guardrailed
  • Surface relevant rules inline instead of hiding them behind secondary flows

This was less about adding capability and more about giving users a reliable sequence to move through.

Discovery and Evidence

The second design question was how validations should scale.

Model A kept validation details inline for faster scanning and easier one-click import.

Model B separated concerns into tabs, which reduced noise and would scale better as rule sets grew.

For v1, I chose the inline model because it preserved flow momentum and made the workflow easier to understand in the moment. Tabs remained the deliberate fallback once rule density outgrew the simpler model.

Solution

The final direction combined two linked experiences:

  1. An apply flow in NextSet that focused on unmapped gaps, explicit selection, and predictable import behavior
  2. An authoring flow where three inputs - shape, validations, and annotations - fed one live preview

"We were trying to add garnish... when we were missing a whole side."

Product lead, on scope discipline

The key move was to define the contract model first, then simplify the UI around that model instead of layering more reveal states on top of an ambiguous foundation.

Implementation

I translated the design into implementation-ready decisions:

  • Defaults and edge cases for select -> import transitions
  • Clear guidance on which parts of the workflow users could edit directly
  • A shared preview model so authoring and apply stayed aligned

That detail mattered because this feature had to ship, not just test well in design review. The clearer the contract model became, the faster engineering could move without reopening the underlying interaction questions.

Results

The redesign turned templates from a field-list feature into a reusable contract workflow.

  • Teams moved through create -> preview -> apply with fewer ambiguous handoffs
  • Engineering received a clearer interaction model and tighter defaults
  • The product gained a more defensible path for scaling rules and governance later

Reflections

This project reinforced a pattern that shows up often in enterprise design: when a feature feels confusing, the fix is usually not a prettier surface. It is a clearer model, smaller decisions, and defaults that teach users what the system is doing.