The problem
Long term freight was a new model in an industry built on the spot market. Carriers were used to picking up single loads, and planning still relied on calls, meetings and email threads. More than 30% of trucks on US roads run empty (Leaf, February 2022).
Leaf had the data and the predictions, but no product that made the model easy to understand or use. The first version, a proof of concept created before I joined, showed single loads rather than a network, and had no system to grow on.
To scale, Leaf needed three things: carriers who understood and trusted the network model, orders created in software rather than by hand, and a design foundation that could support every app.
When the model changed
Leaf moved beyond a pure marketplace model. It began contracting set volumes of lanes from shippers and allocating them to carriers. An in house analytics team combined freight from several shippers into networks and fed them into the product.
The product, however, could only list single lanes. Networks needed to be made visible: circuits, power lanes, the time between stops, and the requirements that determine whether a carrier can take a load, such as equipment, warehouse windows, and drop or live loading. Designing this was my responsibility.

Goals
- Make the model click. Carriers should be able to see a network opportunity and understand why it is better than single loads.
- Move planning into software. Orders and plans should be created in the platform rather than over email.
- Build once, reuse everywhere. A single design system should serve the carrier, shipper and admin apps.
Learning the domain
Since I had no background in US freight, I started by learning the domain. I watched hours of training content for brokers, dispatchers and drivers, analyzed the major load boards, interviewed our Customer Success team, studied analytics and Hotjar recordings, and conducted interviews with about ten people from carrier companies of different sizes.

I start every new project with a heuristic evaluation. It is the fastest way for me to learn a product, and it adds value from the first week by showing the team what I think needs fixing first. At Leaf, I created an evaluation template and ran it with Stefan Friederichs, our CTO, who was also acting as product owner at the time, and with the previous designer. Among other issues, the proof of concept could not display network moves at all, and it used the brand color for error messages. We each scored every issue, ranked them together, and fixed the most important ones first.
A shared language
Long term freight is built on concepts that are difficult to picture, and the most difficult of them was the power lane. A lane is a route between two locations. A power lane is a cluster of nearby lanes that can replace one another, allowing a carrier's truck to keep moving through the network instead of driving back empty. It is the core of Leaf's value, yet almost impossible to explain in words. Even within the team, people described it in different ways.
Before designing any screens, I therefore built a visual language for it. I started from what everyone already knows from Google Maps and Apple Maps: start and end points, stops in between, and arrows showing direction. On this familiar base, I added the elements specific to freight: lanes grouped into power lanes, trip types such as roundtrips and continuous moves, loading and unloading, and a clear way to show empty miles.
This gave product, engineering and operations a shared way to talk about the network, and gave carriers a way to see why it is better than single loads. Sales and investor presentations used the same language to explain the network. As the only in house designer, I also designed those presentations, along with the website and the brand material. The visual language later became the basis of the design system.
716 mi deadhead
0 mi deadhead
0 mi deadhead
0 mi deadhead
0 mi deadhead
0 mi deadhead
0 mi deadhead
780 mi deadhead
Design system
I worked closely with Stefan and an engineering team that grew from about four to eight people as Leaf built its in house team. A dedicated PM joined later. Together, we built three apps: carrier, shipper and admin.
Set the foundation. I ran a one week workshop with the CTO to define the core of the new carrier app and the design system: the visual language, the key flows and the first components. The first redesigned release, a rebuilt dashboard, shipped within a few months of my start.
Four rules for the system.
- Use existing components whenever possible.
- A new component must not break rule one.
- Scale through templates that do not conflict with existing components.
- Design systems, not isolated features.
Inspired by Asimov's three laws of robotics.

Agree on scope together. I organized workshops with product, engineering and Customer Success to define the MVP, its user flows, and the components each future feature would reuse. After launch, regular design reviews with Customer Success determined the next priorities.
Validate with the people who know freight. We first reviewed every concept with Leaf's own logistics experts and operations team, and then tested it with carrier and shipper companies through interviews and prototype sessions. Their feedback shaped how we presented power lanes, trip types and schedules, and what carriers needed to see before they were willing to quote.
The apps
The carrier app: find freight that fits your trucks. Carriers come to Leaf for long term work. The board lists every open opportunity next to a map of the entire network, so carriers can see where freight runs rather than looking at one load at a time. Each card answers the questions a dispatcher checks before quoting: where the freight starts and ends, how far it travels, what kind of trip it is, which trailer it needs, and how often and for how long it runs. Carriers set their interests once, and every matching opportunity is marked with a target icon. From there, they can save it, share it with anyone without a login, or submit a quote.
Example. Consider the opportunity from Allentown to Raleigh: a continuous move of 485 miles in three legs, with three trips a week. Each leg carries freight from a different shipper, so the truck stays loaded from the first pickup to the last delivery. The carrier opens the route, checks the schedule and the requirements, and sends a quote.


ActiveQuote added
ActiveQuote added
ActiveQuote added
ActiveQuote added
ActiveQuote added
ActiveQuote added
ActiveDay ofLinehaul RPM $3.05No changesCancelCancel quote · not part of this demo
ActiveExp. Feb 8, 2021Week ofLinehaul RPM $2.863 changesCancelCancel quote · not part of this demoNo favorites yetStar an opportunity to keep it here.
0 mi deadhead
0 mi deadhead
0 mi deadhead
0 mi deadhead
0 mi deadhead
250 mi deadhead
0 mi deadhead
0 mi deadhead
450 mi deadhead
0 mi deadhead
385 mi deadhead
346 mi deadhead
Orders
Status
Accessorials
Loading type
Hazmat

The admin app: run the network. Leaf's own team works in the admin app. It covers reporting, accounts, contracting and execution, everything between a shipper's volume and a truck on the road. Contract groups is where all of this comes together. Each group bundles lanes from one or more shippers into a single contract for one carrier, with its status, trip type and dates.
Example. A contract on the same route, Allentown to Raleigh, appears here as contract group #100041: three lanes from three shippers, run by one carrier as a continuous move. Opening the group shows all 39 trips, each with its pickup and delivery windows, price per trip and per mile, and status. The side panel contains the terms, the progress (22 of 39 trips), the rates, the extras paid on every trip, and the estimated value of the entire contract, $64,500.15.


Shippers and admins: plan once. Order creation moved from calls and emails into the product. The most complex case was a contract that carries goods from several shippers at once. Users enter the weekly volume once, and the platform generates each daily plan, which can be edited day by day. Orders can be saved as "In planning" before exact times are known.
One system behind every app. The carrier app came first, and the shipper and admin apps followed on the same system. Domain components for lanes, schedules, date selectors and statuses sat in the library alongside the basic components, so every new flow was faster to build and consistent from the start.
Outcome
By February 2022, two months before I left, Leaf reported more than 425 shippers and 550 carriers on the platform, 10x year over year growth and a $37M Series B (Leaf, February 2022). The carrier, shipper and admin apps these customers worked in all ran on this system.
Carriers could see and share network opportunities in one place, and orders moved from calls and email into the platform.
Reflection
- Understand the domain before designing. Learning how freight works made the workflows simpler.
- Borrow what people already know. Starting from familiar map patterns made a difficult concept readable.
- Build the system early. Components created in the first months made every later app faster to build.
- Ship, then listen. Hotjar and in app feedback from operations identified the next problems to solve: data mismatches between orders and opportunities, and routing issues.
There is more to this project than fits on one page.
Get in touchUp next