The DriveApp Revamp

ROLE
Design System Designer
DURATION
3 months of design (about 20 hours a week), development in progress
TEAM
1 Drive App product designer, 1 product manager, 1 developer consultant

Overview

Geotab Drive is the app truck drivers open every day. They use it to log their Hours of Service, inspect their vehicles and trailers, and see where they’re going next.

For the revamp we started over, and I built the design system, Zenith for Drive App: colours, type, spacing, components and documentation.

It had to work on a phone in the driver’s hand, a phone in a mount, and a tablet in a mount.

Four Drive App screens in driving mode: a violation alert on a phone lock screen in light and dark, and the driving timer on a tablet in portrait and landscape, all with large type and a single large button.
Driving mode on phone and tablet, in light and dark

The challenge

Each of those asks something different of the app:

  • Phone in hand: the driver has time and both hands free. Standard sizes are fine.
  • Phone in a mount: the truck may be moving, so the driver can only glance at it. Text has to be readable in a second, and taps can’t miss.
  • Tablet in a mount: the screen is further away, so everything has to be bigger.

The old Drive App was built in the early 2000s and hadn’t changed much since. It looked dated, it was slow, and there was no system underneath it.

We needed one set of components that could resize for each case, so designers wouldn’t have to rebuild every screen for each one.

Foundations

I started with tokens, so that everything built on them could change with a mode.

  • Colour: 126 primitive colours in 9 families, mapped to 31 semantic tokens for text, background, border, badge and overlay, each with a Light and a Dark value.
  • Status colours: a colour for each Hours of Service status, from Driving and On Duty to Sleeper Berth and Personal Conveyance, so drivers can tell their status at a glance.
  • Type: Roboto in three groups: headings, body and data (for hours, distances and scores). Every style has a Large twin.
  • Spacing and corner radius: xs to xxl spacing and s to l radius tokens, each with a Standard and a Large mode.
  • Grids: mobile, tablet portrait and tablet landscape.
The Drive App colour palette in light mode: nine families of base colours from darkest to lightest, then semantic colours for text, background, border and badges, and a row of colours for each Hours of Service status.
Base colours, the semantic tokens built on them, and a colour for each duty status
The Drive App heading styles side by side. Standard: Page, Nav, Title and Label headings in Roboto. Large, for driving mode and tablets: the same four styles at bigger sizes, with their font, weight, size and line height listed beside each.
Every type style has a Large twin for driving mode and tablets

Driving mode

Driving mode is the part I’m proudest of. A driver with a phone or tablet in a mount may be moving, and can only glance at the screen. Every second their eyes are on the app is a second they’re not on the road, and a missed tap means reaching for the screen again.

So I designed the Large mode of the tokens around safety and accessibility first. Each change answers one question: can the driver read it, or hit it, the first time?

  • Type: headings about 40% larger and body text about 50% larger, with line heights scaled to match. Text in a mount is read from arm’s length, in one quick look, so it has to be legible without leaning in.
  • Touch targets: at least 76 × 76px, and 96 × 96px wherever space allows. That’s well above the usual 44–48px minimum, because a hand reaching for a mounted screen in a moving truck is far less precise than a thumb on a phone.
  • Icons: 24px in Standard, 48px in Large, so drivers can recognise them at a glance. The tap area can be bigger than the icon, and the hand-off shows the padding that makes up the difference.
  • Padding: every spacing token grows by 4px in Large. More space between controls means fewer taps on the wrong one.

The changes live in the variables, not in separate screens. Components use semantic tokens, so switching the variable mode from Standard to Large resizes a whole screen at once. Designers only step in when the bigger type and padding start to look disconnected, or when a page needs its own layout.

On a phone

In the driver’s hand, the phone uses Standard. Once the driver starts driving, the app locks to a driving screen: only their hours, in large type, and one large button.

Two phone screens. Standard: the Drive App home screen with My Hours, Your Assets and Your Trip. Driving: a dark lock screen with the drive time left in large type, a progress bar marking the next break, the time until break, total shift and cycle left, the current task, and one large round microphone button.
On a phone: Standard in the driver's hand, and a lock screen once the driver starts driving

On a tablet

A tablet sits in a mount, further from the driver, so it uses the Large mode all the time. Once the driver starts driving, it locks to the same kind of driving screen.

My Hours on a tablet in Large mode, with notes on its larger headings, touch targets, body text and padding.
A tablet uses Large mode all the time

Light and dark

Drivers use the app at every hour, and a bright screen in a dark cab at night is hard on the eyes. So every colour token has a Light and a Dark value, and every component works in both from the start.

Designers don’t draw a dark version of a screen. They switch the variable mode, and the whole screen changes with it. The header is the one exception: its gradient can’t be a token, so it has its own dark variants.

The Drive App home screen in light and dark mode, side by side. In dark, the header starts near-black and fades into blue, the cards are one step lighter than the background, the Assign now link turns a lighter blue, and the bottom nav is a dark bar.
The same Home screen in Light and Dark. Only the variable mode changes.

Components

I built about 27 components, and each one had Standard and Large sizes and Light and Dark modes from the start. Some of the main ones:

  • Header: 36 variants across phone and tablet, light and dark, and six layouts such as tabs, search and the home page. A status pill shows the driver’s Hours of Service status from anywhere in the app.
  • Alerts: made for driving mode only, and shown on the locked screen for violations and warnings.
  • Fields: text, dropdown and search, with default, active, error and read-only states.
  • Lists: standard, notification, asset and settings lists, all built on the same structure.

I set each component up so designers shouldn’t ever need to detach it:

  • Seamless changes, controlled by tokens: colours, padding, gaps and corners all use tokens. Switch the mode and every component updates.
  • Only the variants you need: variants cover device, type and state. Everything else, like hiding an icon or editing a label, is a simple property.
  • Shared building blocks: small base components like icons, tabs and menu items sit inside the bigger ones, so fixing one fixes it everywhere.
  • Guidance in the panel: each component has a short description, so designers see how to use it when they insert it.
The Navigation / Header component set: rows of blue light-mode and navy dark-mode headers for phone and tablet, with a page title, back button, an OFF status pill and notifications, in layouts with tabs, a search field and the driver's name.
Header variants across devices, modes and layouts. The header uses a gradient, which tokens can't switch between modes, so it needs more variants than other components.

From Figma to code

I think the future of design system work is one person looking after both the design and the code. Design is my background, and with AI tooling I can now write code quickly too. My front-end knowledge lets me review that code line by line and ship it to a high standard. I want to be a designer who moves seamlessly between the two.

On this project, I didn’t stop at the Figma component. Using Geotab’s internal AI tool, which runs on Claude Opus 5.5, I coded the Button in React and matched the Figma component 1:1: the same variables, sizes, states and properties. Developers got working code to start from, not just a spec.

Try it: change its properties, tap it, or edit the code.

Micro-animation

Micro-animations used to be the first thing cut. Motion is slow to describe in a spec, and building it took developer time the team didn’t have. With AI tooling, I can now build an animation myself in a fraction of the time, tune it until the feedback feels exact, and hand over the code. Small details like this are what make a product feel finished.

The asset list is an example. When a driver taps a row, its background changes colour and the row shrinks slightly, so it’s clear the tap landed. Switch to Slow to see the detail.

Documentation and hand-off

Every component page uses the same template, in this order:

Devices (Standard / Large) / Modes (Light / Dark) / Spec / States / Variants / Responsiveness / Examples / Dev hand-off

The responsiveness notes cover mobile, tablet portrait and tablet landscape. The examples show the component in real screens like My Hours, Settings and Select Vehicle.

The documentation page for the primary button, from top to bottom: Devices (Standard and Large), Modes (light and dark), Spec, States (default, tapped, loading), Variants, Responsiveness and Examples.
One template for every component, from spec to dev hand-off

What’s next

I spent about 20 hours a week on the Drive App, and designing and fine-tuning the system took three months. Now I’m working with the Drive App designer to code the components with AI tooling and use them in the new app.

After launch, we’ll add more features, like navigation, maps and messaging. Stay tuned!