EdTech

Company

(Edtech company)

Timeline

2024 - 2026

Role

Product Designer

(Edtech company) Students data table � desktop and mobile

Executive Summary & Impact


  • Role: Lead Product Designer (Solo UX/UI & System Architecture)

  • Scope: Core Data Table Architecture (~75% of total product views)

  • Core Objective: Single-handedly lead the modernization of (EdTech company) legacy OS 2.0, to the newer 3.0 OS by establishing a scalable component library, untangling 13 years of legacy workflows across 5 distinct operational table modes, and standardizing/streamlining developer handoff, as well as buildouts using AI.

Setting the Stage: The Mandate & Legacy Debt

When I joined (EdTech company) as Lead Product Designer, my mandate was straightforward: untangle 13 years of technical and visual debt to bridge a legacy K-12 compliance platform (2.0) into a modernized OS (3.0), while building a codable design system from scratch.

Used daily by tens of thousands of athletic directors, school nurses, coaches, and district administrators, (EdTech company) replaces paper forms and spreadsheets to manage student registration, medical clearances, and athletic eligibility. Data tables are the engine behind all of it—powering legally binding actions across 75% of the product's views. Yet for over a decade, every user persona had been funneled through the exact same rigid, bloated table interface.

Over nearly two years, I owned this system modernization end-to-end. While engineering owned the build, I led the user research, testing, pattern library, component specifications, and architectural decisions that unified five distinct school workflows into one flexible table system.


Discovery: Building the Room & Widening the Investigation

To understand where the legacy system was breaking down, I needed to look beyond the screen and talk to the people who lived inside it every day.

Quarterly Workshops

I initiated and facilitated a quarterly, 90-minute workshop that pulled over 60 teammates across engineering, support, onboarding, and sales into a single collaborative space. This served as a structured temperature check: a safe forum for venting pain points and uncovering collaboration opportunities. Because these teams interacted with clients through different lenses, they immediately surfaced the friction points in our software—the vast majority of which were tied directly to our rigid data tables.


Alongside these workshops, I ran individual 1-on-1 sessions with teammates who flagged specific interface bugs and sat in on live calls with the sales team to understand what prospects were complaining about—and crucially, why we were losing deals. Synthesizing these insights with competitor research and sales calls gave me a clear, unfiltered view of what needed to change.


Diagnosing the UI Debt: The Index Was Louder Than the Work

A comprehensive UX audit revealed an immediate culprit behind user fatigue: visual noise and choice fatigue across our index pages. The same buttons were repeated endlessly with no clear visual hierarchy, and solid primary button styles were being overused everywhere.

On the sports index, for example, that showed up as a bright blue primary button on every single row. A primary button is meant for the single most important action on a screen (such as New Sport). Repeated on every row, it stopped signaling importance entirely. Roster, Coaches, and Inventory all competed at the exact same visual volume, compounded by even more actions stacked onto the row.

Applying Hick’s Law made the outcome clear: decision time goes up as the number of choices goes up, and so does the likelihood of a misclick.

Working closely with our CPO, I completely reset the hierarchy. While these core adjustments were the most visible, they were part of a much broader series of table optimizations:

  • Row-level actions were stepped down from solid primary buttons to clean text links.

  • Secondary operations were consolidated into a single, organized Actions menu.

  • The sport name itself became the interactive link, removing the need for a redundant button just to open a record.

  • Destructive actions (like Delete) were assigned a distinct red danger state, making catastrophic misclicks much harder to execute by accident.

  • Conditional icon visibility: Cleaned up clutter by displaying icons (like compliance or medical flags) only when active.

  • Sticky table headers & section headers: Improved scannability for long lists of student data so context is never lost during scrolling.


Legacy and new student index. Student details are hidden.

What the Data Said: Usage Metrics & Form Factors

Before deciding how mobile-first this redesign needed to be, we analyzed real GA4 usage data across 1.54 million users to understand our actual behavioral split:

  • Parents interacted with the platform roughly 2:1 mobile to desktop.

  • Students were split nearly evenly between desktop and mobile.

  • Staff—the primary users working inside these complex tables—were roughly 3:1 desktop. Their daily tasks were inherently designed for desktop environments.

(Note: While parents complete registration on mobile, that workflow is a separate consumer flow outside the table ecosystem. The table is a staff instrument, and our metrics dictated that it be optimized for desktop productivity.)



Building the System: Dual-Track Design & Engineering Handoff

As the sole product designer leading this transition, I couldn't just design static screens in a vacuum. The entire purpose of my hire was to bridge the legacy system (2.0) into a modernized ecosystem (3.0) while building a scalable design system from scratch.

This required a rigorous dual-track workflow:

  1. Documenting the Legacy UI Kit: While auditing and modernizing views, I reverse-engineered legacy 2.0 patterns into a formal retrofitted UI kit. This gave engineering an explicit reference point for legacy edge cases and existing behaviors during the migration.

  2. Authoring the 3.0 Design System: In parallel, I built out new design tokens, auto-layout component variants, and accessibility standards for FinalForms 3.0.

By creating components that were fully structured for developer handoff, every new table view I shipped fed directly back into our centralized pattern library—drastically reducing frontend build time, eliminating UI drift, and giving engineers clean, predictable specs to build against.

Documentation Example #1: File for Documenting Interaction Patterns


Documentation Example #2: Advanced Filter Parameter Map




Systemizing Interaction Patterns & Edge Cases

Redesigning a high-stakes compliance table meant going far beyond standard rows and columns. To ensure a bulletproof handoff for engineering, I built a dedicated 3.0 Interaction Patterns file in Figma. This repository documented end-to-end component behaviors, guardrails, and guidelines across critical workflows:

  • Tables · Sort & Filter: Structured inline and advanced filtering frameworks, allowing administrators to filter by status, tags, priority, assignee, custom dates, and building locations without losing their place.

  • Tables · Bulk Actions Flow: Designed secure multi-row selection patterns with clear counts, safe select-alls across large datasets, and confirmation gates for destructive batch operations.

  • Tables · Empty & Loading States: Defined fallback layouts to prevent layout shift and guide users when search yields zero results or data is actively fetching.

  • Tables · Add a Column Flow: Built scalable side-drawer mechanics allowing users to customize their view configuration dynamically.

  • Tables · Clearances: Mapped out complex compliance states for medical physicals, custom district requirements, and historical audit tracking.


Documentation Example #3: Interaction Patterns Working File



Architectural Decisions: Drawers, Modals, and Multi-Modes

Choosing where an action took place was critical to maintaining administrative flow:

  • Use Drawers when the list still matters: Adding a column, scanning a quick student profile, or building an active filter are auxiliary tasks. The underlying roster needs to stay visible so users don't lose context.

  • Use Modals when the action cannot be undone: Adding a student, marking someone as withdrawn, importing a CSV, or rolling over the school year are short, high-risk, or destructive actions. These require a modal to capture total focus until the user explicitly confirms.

    Documentation Example #4: When to use Slide-In Drawer vs. Modals

Drawer versus modal decision.

Documentation Example #5: Side Drawer Specs for Dev Handoff



Documentation Example #6: Profile Page Revamp


Annotated new student profile. Student details are hidden.

One Table Shell, Five Dynamic Modes

The table architecture had to seamlessly adapt to 5 distinct operational modes without feeling like 5 separate products: Academic, Athletic, Extracurricular, Medical, and Enrollment.

For example, Academic and Medical are two modes running on top of the exact same table component shell. The container stays consistent, but the inner columns, data points, and row actions dynamically adapt to the workflow:

  • Academic Mode covers enrollment, paperwork, and classroom compliance.

  • Medical Mode surfaces health records, emergency clearances, and physical exam dates.

  • A coach viewing a roster sees athletic-relevant data, while medical triage items are restricted from their view.

Documentation Example #7: The Differences in Table Modes

Academic and Medical modes of the same student table. The product name is hidden.

Stress-testing the patterns

A data table is much more than the displaying of rows and columns of data: There are a myriad of patterns that go into building a scalable, high-velocity workspace. All of the patterns were thoroughly researched, and tested, with internal staff, as well as real-life users to make sure the user could accomplish their tasks easily, and to reveal any potential edge cases. Certain flows, that were categoeized as an admin task, were optmized for desktop, whereas a task a student or parent would be executing, were optimized for movile.

While the full system encompasses dozens of granular interaction models, I selected six key patterns to highlight how we stress-tested the UI against complex, everyday user workflows:

  • Adding a Column (Customization): Allows users to tailor data density to their specific role—letting power operators surface critical fields while hiding non-essential metrics to streamline daily tasks.

  • Loading State (System Feedback): Prevents UI layout shifts during asynchronous data fetches, maintaining visual context and managing user expectations during heavy server calls.

  • Sorting (Data Scannability): Enables rapid reorganization of vast datasets by priority, recency, or alphabetical hierarchy without losing visual anchor points.

  • Bulk Actions (Workflow Efficiency): Accelerates high-throughput management by allowing users to select records across pages and execute batch operations in a single step.

  • Pagination (Performance & Structure): Breaks thousands of records into manageable, performant chunks—reducing cognitive load while eliminating browser rendering bottlenecks.

  • Advanced Filters (Targeted Discovery): Empowers users to layer complex criteria logic to slice through large datasets and isolate exact data points instantly.


Building the System: Dual-Track Design & Engineering Handoff

As the sole product designer leading this transition, I couldn't just design static screens in a vacuum. The entire purpose of my hire was to bridge the legacy system (2.0) into a modernized ecosystem (3.0) while building a scalable design system from scratch.

This required a rigorous dual-track workflow:

  1. Documenting the Legacy UI Kit: While auditing and modernizing views, I reverse-engineered legacy 2.0 patterns into a formal retrofitted UI kit. This gave engineering an explicit reference point for legacy edge cases and existing behaviors during the migration.

  2. Authoring the 3.0 Design System: In parallel, I built out new design tokens, auto-layout component variants, and accessibility standards for FinalForms 3.0.

By creating components that were fully structured for developer handoff, every new table view I shipped fed directly back into our centralized pattern library—drastically reducing frontend build time, eliminating UI drift, and giving engineers clean, predictable specs to build against.

Documentation Example #8: Mobile Patterns


Closing Impact & Takeaways

Modernizing 75% of a 13-year-old compliance platform as a solo designer required treating the UI not as a collection of static screens, but as a programmable system. By pairing deep cross-functional discovery with strict component governance, I turned five fragmented administrative workflows into a single, adaptable table architecture.

Integrating AI directly into the design system pipeline—using Cursor to enforce token hygiene and Claude to stress-test edge cases—allowed me to operate at the speed of a full systems team. More importantly, structuring every layer, variant, and token for tools like Claude Code eliminated the traditional translation gap between design and engineering, ensuring the system scales cleanly long after handoff.


(Cursor)

(Claude)

What is ready

The system is specified to the point that engineering can build it for the schools already on the platform, about 4 million students and families. The table is not one audience. Athletic directors, coaches, nurses, secretaries, and registrars use it to finish compliance work. Parents and students meet it when a form, a physical, or a clearance decides whether someone participates. It has not shipped, so there is no adoption number. What is ready is the pattern library, the decision record, and the specs for the flows those people already depend on.

Ready to turn coffee (or matcha) into code and features?
Let's chat!

Denver, CO

4:55 PM

Socials

© 2026 George Chi

Product & UX/UI Design

Ready to turn coffee (or matcha) into code and features?
Let's chat!

Denver, CO

4:55 PM

Socials

© 2026 George Chi

Product & UX/UI Design