Don't
Get
the
Wrong
Idea

Handling convoluted systems at a massive scale

Over years of advising as a professor/advisor, I saw the same pattern over and over during advising sessions:

• Students walked into office hours anxious and confused about graduation requirements.
• They were terrified of taking the wrong class and needing to take on more loans, or delaying graduation by a term or two.
• They often had conflicting advice — from other students, different advisors, or half-understood degree audits.

The system was complex and opaque, and students were understandably confused. Hell, I was often confused. There are so many courses and pathways to graduation, and it's nearly impossible to get a complete picture of what to do.

As an advisor, I had to:

• dig through degree/graduation audits, the course catalog, and internal docs
• reconcile edge cases (transfer students, double majors, changing catalog years)
• redraw almost the same exact hand-written term-by-term plans for each student
• do my best to keep track of all my assigned students, especially the ones never checked in or were drifting off track

Meanwhile, administrators:

• had no clear view of which courses students were planning to take
• regularly created sections that ran half-empty, or had to scramble for last-minute extra sections when classes filled
• couldn’t easily identify at-risk students early, before problems compounded

It was massive institutional complexity being addressed by pen and paper, a dozen obscure websites, and worst of all — enterprise systems designed by engineers, not by the people who had to live in them.

GradSync was my attempt to design a tool that put students at the center, while still giving advisors and administrators what they needed to do their jobs well.

Methods

In order to better understand the problem, I used a combination of methods to gather insights:

• 1:1 interviews with students, advisors, and admins
• Direct observation during advising sessions
• Hands-on use and analysis of existing tools (Ellucian, uAchieve, Anthology, EAB Navigate, etc.)
• Dozens of user tests of various tools and app versions with students and advisors across several years and across multiple institutions

Observations and notes from interviews and user tests

Here are some of the key insights I gathered from my conversations with students, advisors, and administrators:

Students

• They often made decisions with partial or outdated information.
• Showing the information visually worked considerably better than explaining verbally or in text.
• Every student felt like an edge case; only a small minority of students followed the "golden path" schedule to graduate with their chosen major.
• Even when they were 100% right, they often felt sure they were doing something wrong.

Advisors

• They repeated the same explanations dozens of times per week.
• Most of their “advising” time was spent reading requirements out loud and translating jargon, not truly advising.
• Student plans were incorrect and/or unreliable as they spoke to different advisors, as time passed, and as their goals and progress shifted.
• It was hard to track which students were getting off-track, especially as those students were often the ones who were least proactively checking in with their advisors.
• Universities that used enterprise systems to aid in advising often described how frustrating they were to use. In many cases, they simply avoided using them altogether.

Administrators

• They lacked reliable visibility into future course demand.
• They regularly ran under-enrolled classes (wasting money) or overfull classes (hurting students).
• They knew “retention” was a priority, but lacked timely, actionable data about students whose plans had quietly broken.

Understanding the competition

A lot of time was spent using and analyzing existing tools and systems to understand the competition. Here are some of the key findings:

• Most software treated requirements as a data problem, not an experience problem. Interfaces were heavy, slow, and completely unintuitive.
• The underlying data (especially in systems like PeopleSoft) was incredibly convoluted and opaque.
• Degree audits (like DARS) technically contained the information, but were ugly, text-heavy, and cognitively hostile.
• Graduation planning tools often assumed an "ideal" situation for all of their users, and required excessive workarounds when students weren't aligned with that ideal (e.g. assuming students knew exactly which courses they wanted to take for every term, even years into the future).

---

Core UX principles

From the research, we defined a set of guiding principles:

Visual before textual

Show a year-by-year timeline with terms and courses, not just a wall of text. Let students (and advisors) see their past, present, and future at a glance.

Real-time validation

Prerequisites, credit minimums, duplicate courses, etc. are checked as the student drags things around — not after.

Freedom first, rules as guardrails

Let students try things in any order (even “wrong” ones), then explain why something doesn’t work, instead of blocking them upfront.

One hub, not twelve tabs

Pull course descriptions, terms offered, requirements, and plan status into one interface instead of sending users to a catalog, a PDF, an audit, and an email trail.

Speed matters

The UI had to feel instant. Most app logic runs locally in the browser so drag-and-drop, stats, and validation all get updated without a page reload.

Key UX decisions

Visual, drag-and-drop planning

Students and advisors saw a year-by-year grid of terms. Courses could be dragged into any term, reordered, or removed. As they did:

• The requirements were checked off as courses were added, and the list updated in real time.
• The system flagged issues: missing prerequisites, overfull terms, courses not offered in that term, etc.

Unlike other planners that forced users through a strict sequence, GradSync allowed messy, non-linear planning — the way people actually think. You could plan backwards from a graduation term, try a new minor, compare majors, and see the ripple effects in real time.

Placeholders for uncertainty

Other tools often required students to make decisions too early (e.g. “Which specific elective do you want to take in your senior year?”).

GradSync introduced placeholder courses: stand-ins like “Upper-division elective” or “One of these 5 options” that satisfied requirements and kept the plan valid, while allowing details to be decided later.

This matched reality: students and advisors could create a viable skeleton of a plan today, then refine over time.

Real-time feedback instead of trial and error

When something didn’t work, GradSync didn’t just block the action. Instead it:

• Highlighted the problematic course or term
• Explained why (“Missing prerequisite: ART 214” / “Course not offered in Spring”)
• Suggested next steps (move course, swap sequence, adjust load)

This also worked for situations where a course was not offered in a given term or when a student failed to complete a course they had planned to take. In cases like these, the app would notify the student and advisor, and suggest next steps.

Advisor tools built into the same experience

Advisors saw what students saw — plus were able to:

• Run reports to find students with invalid or missing plans
• Approve plans in a click
• Add contextual notes on specific terms or courses
• View plan history and previous versions

Accessibility and multiple interaction models

Because this tool mattered for all students, we:

• Designed for WCAG 2.1 Level AA compliance
• Added thorough ARIA labelling for dynamic components
• Built full keyboard-only flows for students who can’t or don’t use a mouse
• Provided non–drag-and-drop ways to add/move courses via modals and shortcuts

Together, these decisions shifted planning from a brittle, error-prone process into something exploratory and resilient. Students could make mistakes safely, advisors could intervene earlier, and the system quietly ensured nothing important slipped through the cracks.

Design goals

• Empowering, not intimidating

  Graduation planning is high-stakes. The UI needed to say “We’ve got this,” not “Don’t screw this up.”

• Approachable, not playful

  This wasn’t a kids’ app, but we still wanted to feel more human and approachable than the typical vendor’s “enterprise” aesthetic.

• Distinct from big-vendor corporate

  We intentionally positioned GradSync as the thoughtful, design-led alternative to massive incumbent vendors.

Visual decisions

• Color palette

  Teal and cyan as core colors created a sense of freshness and clarity, without feeling juvenile. Accent colors were used to communicate status (valid, in progress, needs attention) rather than as decoration.

Layout & hierarchy

The term grid gave students a literal map of their academic future. The collapsible sidebar requirements provided a single, scannable reference instead of making users dig through multiple documents.

Typography

We chose type that was clean and readable over long sessions, with enough personality to feel designed — but not so much that it drew attention away from the content.

Micro-interactions

Hover states, validations, and transitions were tuned to feel snappy and reassuring, not flashy. Most of the “wow” came from how much information was available in one place, not from visual tricks.

Visually, GradSync turned an overwhelming, abstract problem into something finite and navigable. The interface didn’t trivialize the stakes—but it removed unnecessary intimidation, replacing it with clarity and a sense of progress.

---

Seeing the impact

How students felt about it

Students could build a valid, advisor-ready plan in minutes instead of weeks of piecemeal emails and appointments.

• They better understood why certain sequences mattered (prereqs, credit minimums, term offerings).
• Students who self-advise—which is most of them—were able to build a valid, advisor-ready plan in minutes instead of weeks of piecemeal emails and appointments. This gave them a sense of control and confidence in their academic journey, and it sped up advising sessions by giving us a starting point to work from.

How it helped advisors

• What used to be a 20–30 minute “let me explain this PDF” conversation often became a 4–5 minute review and refinement.
• Advisors could see which students had no plan, which plans were invalid, and which students were falling behind — and reach out proactively.
• Notes, plan versions, and time-stamped changes reduced confusion about who had agreed to what, and when.

How it helped administrators

• Pilots demonstrated how course demand forecasting and student-status reports could prevent under- and over-enrolled courses and help identify at-risk students earlier.

Why we ultimately shut it down

Despite strong reactions from students and advisors, we hit structural barriers. Universities are highly risk-averse and slow to adopt new vendors, and as a two-person team, we were competing with large, entrenched companies deeply embedded in institutions’ contracts and ecosystems.

We wound GradSync down in 2025 — but the project left me with a few lasting lessons:

• I love designing complex tools; I don’t love running a software company.
• Institutional problems are often solvable with good UX — if you take the time to deeply understand the system and the humans inside it.
• People who live in complex systems (particularly students and advisors) are hungry for thoughtful design. They’re often the ones most excited to collaborate.
• Rigidity is as big of a problem as complexity, even in a rules-based system like graduation planning.
• GradSync didn’t “fix higher ed,” but it proved something important: when you respect people’s time, attention, and anxiety, the right design can turn a terrifying maze into a clear, navigable path.