Concordia Mobile App
2025
Building a shared language for digital products across the university
Client
Concordia University
My Role
Design system designer & front-end
Team
Timeline
2025 – 2026
Concordia’s digital footprint spans dozens of sites, tools, and teams — each shipping interfaces with slightly different patterns, typography, and interaction models.
Without a shared system, teams duplicated effort, accessibility drifted, and students encountered inconsistent experiences as they moved between services.
The live product is the Concordia Design System on concordia.ca/brand: a component catalogue authors actually use, a token layer compiled into every AEM page, and brand standards that used to live in PDFs. Tokens are the foundation — they only matter because of the patterns, guidance, and contribution paths built on top of them.
Outcomes at a glance The system is in production — not a Figma-only kit. A brand decision can change in one place instead of a hundred files, and authors get a catalogue instead of a PDF.
53 documented blocks in the catalogue — not a PDF, and not primitives only.
AuthoringColour, type, space, and elevation — not just hex. Colour uses dropped 83% in a 100-file sweep.
TokensSize, weight, and line-height now come from 51 tokens instead of one-off px.
TypeDesigners and developers start from the same documented components and tokens instead of re-deciding them per project.
DeliveryThree surfaces, one living product.
Before the process, here’s what shipped — and is still evolving. Tokens encode the decisions. The catalogue is how teams consume them. Brand standards and tone of voice used to be PDFs; they’re now pages in the same system.
The public home is concordia.ca/brand — design, development, and content guidance in one place, not a slide deck.
Tokens
Colour, type, space, and the rest of the scale — named once, compiled into every AEM page. Live at /brand/web-ui-foundations/tokens.
Consistency shouldn’t depend on who built the page.
Digital work was spread across decentralised teams, each with local standards:
Shipping features on independent timelines.
Owning visual identity and editorial voice.
Each group had good reasons for how they worked. For students and staff moving between tools, the result was friction — unfamiliar buttons, mismatched forms, and uneven accessibility. The harder part wasn’t agreeing that a system would help. It was the environment the system had to ship into. Building here meant working through constraints that never went away:
Thousands of CSS embeds, not a clean stylesheet.
Pages and components had pulled in local CSS for years. The compiled sheet wasn’t something you could restyle — only tokenise, file by file.
Brand guidance lived as historical knowledge.
Standards sat in PDFs and in the heads of people who’d been there when they were written. New teams couldn’t look it up; they asked around, or invented a local version.
Hardcoded values everywhere.
The same grey, the same burgundy, decided again in every file. A brand change meant a hundred-file hunt, not a token update.
No spacing scale for our own components.
Bootstrap 5 gutters handled page structure out of the box. Inside custom components, padding was whatever looked right that day — 10px here, 15px there. Nothing locked those decisions to a grid.
The landscape
9,200 CSS rules. 16,800 style declarations. Years of small decisions compounding into a stylesheet you couldn’t change in one place.
One system, many products
We framed the work around a single question:
What foundation lets teams ship faster while keeping experiences recognizable and accessible?
The work concentrated on three things:
Tokens replace the hex values, type sizes, and spacing steps that had been decided per file. A brand change is one update.
Each catalogue entry covers usage, states, and accessibility — the context authors need when they pick a block in AEM. Brand standards live as pages in the same system.
Authors and product teams inherit the token layer without opting in. It compiles with every page.
Working through the landscape we actually had
We inventoried existing interfaces across high-traffic properties — cataloguing components, variants, and accessibility gaps. A pass through the compiled CSS made the fragmentation visible: colour, type, and space had been decided per file for years.
That audit informed a prioritised component roadmap and the first token set aligned with Concordia brand.
The first version of the system was built in Vue. We then ported it into AEM — the stack the rest of the team already works in — so other team members could contribute to it.
Tokens started as LESS custom properties, then moved to a JSON source so the same file generates CSS and a catalogue authors can search. Production sweeps followed in the files AEM actually compiles: hex to colour tokens, then on-scale margin, padding, and gap onto the 4px spacing scale. Bootstrap’s layout utilities stayed for page structure; off-scale 5, 10, and 15px values were left as pixels so the grid didn’t invent alignments the old CSS never had.
A system teams can ship with
53 documented components, built on one token layer — forms, content, layout, navigation, status, and overlays — each with usage, states, and accessibility guidance tied to real Concordia pages.
There’s no package to install. Tokens ship in the master clientlib, so every AEM page inherits them, and the catalogue on concordia.ca/brand is where authors and developers look up a component before they build.
Shared tokens across design and code
Single naming scheme for colour, type, spacing, and elevation.
Foundations that scale across products.
Brand colour, type, and space are named once — with semantic roles on top of the palette so a component never has to pick a hex. Page layout still uses Bootstrap 5 spacing. Custom component padding used to be one-off pixels; it now has to pick from a 4px token scale. Type uses a named size, weight, and line-height scale. The same JSON generates the CSS custom properties AEM compiles and a catalogue authors can search.
Core UI patterns with documented usage.
The catalogue groups components into families — forms, content, layout, navigation, status, and overlays. Each entry documents when to use the block, its states, and its keyboard and contrast requirements, so authors choosing a component in AEM get the same guidance a developer would.
Want to see more? Check out my other work or get in touch.