
Company
Lune
Role
Product Designer
Scope
Strategy · Domain design · Research · UI
Lune x Gryn: Product Consolidation
When Lune and Gryn merged, the product challenge wasn't visual or structural. It was conceptual. Two companies, two user types, and two fundamentally incompatible ways of modelling the same reality.
Background
Lune built tools for logistics service providers (LSPs), freight forwarders and carriers who needed to calculate and report emissions across their operations. Gryn built tools for shippers, the companies whose goods were actually being moved. In 2026, the two companies merged to create an end-to-end supply chain emissions platform.
On the surface, the products did similar things. Underneath, they disagreed about something fundamental.
The two user types
Logistics Service Provider
Carriers and freight forwarders responsible for moving goods. They needed to calculate emissions across their operations and provide reporting to their shipper clients. Lune was built around them.
Shipper
Companies whose cargo is being transported. They needed visibility into the emissions generated on their behalf, and tools to manage and reduce them. Gryn was built around them.
The real problem
Lune's product treated the calculation as the atomic unit. Every action in the product was anchored to a calculation: you ran one, you reported on it, you managed it.
Gryn's product treated the shipment as the atomic unit. A shipment might have a calculation attached or it might not, but it existed regardless. The shipment was the thing.
Neither model was wrong. They reflected the different realities of their respective user types. But they couldn't coexist in the same interface without a decision being made about which was most useful in the new context, or whether a third model could serve both.
There was also a third wrinkle: Lune supported hypothetical calculations, projections used during tender creation and simulations to estimate future emissions before a contract was signed. Gryn had nothing equivalent. Any unified model had to account for this without surfacing it to users for whom it was irrelevant.


"The question wasn't how to merge two interfaces. It was whether two user types with different mental models could share one domain model without either losing something essential."
Research
Before any design work, I focused on getting the domain model right. That meant interviews with customer success teams from both sides, documentation of user types and their core workflows, and a detailed feature-by-feature analysis of what each product did and for whom.
The CS interviews were particularly useful. They surfaced the real-world edge cases that the product documentation didn't capture. Where did the two products talk to each other in practice? Where were customers already doing workarounds?


Finding a shared model
The resolution came from stepping back from both products' existing models and asking what was actually true at the domain level. A shipment could exist without a calculation. A calculation always belonged to a shipment. Hypothetical calculations were a special case of the calculation concept, scoped to a context (tendering) rather than a user type.
This gave us a model that was genuinely neutral: shipment-first, with calculations as an associated object, and hypothetical calculations surfaced only in the tendering context. The model served both without compromise. LSP workflows still centred on calculations where that was appropriate, and shippers saw shipments with calculations attached where they needed them.

"A calculation always belonged to a shipment. Working backwards from that single fact unlocked the rest of the model."
Design
With the domain model agreed, the design work followed. The unified interface surfaced shipments as the primary object, with calculations accessible contextually. LSP-specific views (tendering, batch imports, operational reporting) were scoped so that shipper users never encountered concepts that weren't relevant to them, and vice versa.
Key surfaces: import batch management, the unified shipment table, and the analytics dashboard, each designed to serve both user types from the same underlying data without either experience feeling compromised.


Final designs




Outcome
There are no headline metrics for this project. It was in progress at the point I left Lune. What I can say is that the core product needs of both user types were preserved in the unified model, the domain decisions were documented and agreed across product and engineering, and the design work was validated with users from both sides.
The harder win was the process: getting two product teams with different mental models into a shared understanding of the domain before writing a line of code. That's the kind of work that doesn't show up in the final UI.
What I took from it
Domain modelling isn't a developer concern. It's a design concern. The decisions made at that level shape every surface, every label, and every user flow downstream. Getting involved early, before those decisions calcify into code, is one of the highest-leverage things a product designer can do on a complex B2B product.
The other takeaway: when two user types disagree about what the fundamental object is, the answer is usually one level of abstraction up. Find the thing both models are actually describing, and build from there.