When a global enterprise’s job portal breaks: a UX audit of a failed candidate flow (White-labeled Case Study)

Summary

While applying for a Senior/Lead-level UX Designer role through a major consulting firm’s candidate portal, I encountered a series of UX failures so fundamental that the process became nearly unusable. Instead of giving up, I audited the entire flow—revealing how poor coordination between design and implementation can completely break an otherwise simple task like creating an account.

In less than five minutes, I uncovered how multiple validation systems contradicted each other, silent errors blocked progress, and the user was left with no clear way forward. This wasn’t just a bug—it was an experience design failure at a critical business touchpoint: the job application.

Flow Summary

The account creation journey unfolded as follows:

1. Email verification: User receives an OTP, enters it, and manually clicks Verify.

2. Mobile verification: User receives another OTP that auto-submits immediately upon entry.

3. Password creation: User sets a password following visible on-screen rules.

4. Account confirmation: User clicks Continue expecting completion—but submission fails silently.

5. Error/lockout handling: Repeated attempts trigger vague lockouts with no recovery cues.

UX Observations (Chronological)

1. Conflicting verification patterns
Two verification flows—email and mobile—worked differently for no reason. Email verification required a manual Verify click, while mobile OTP auto-submitted instantly upon pasting. These conflicting designs set inconsistent mental models for the same task and created unnecessary confusion. To make matters worse, mobile verification only worked when browser cache was disabled—an invisible, technical edge case no user could predict.

2. Password entry contradictions
The UI clearly stated that the password must be “at least 9 characters long, contain no spaces, and include three of the following: uppercase, lowercase, numerals, and special characters.” My password—r2t7mt#5FYe!fye4Geh—met every rule, and the internal JavaScript validation confirmed it. Yet, the form refused to submit.
The cause? A hidden HTML pattern attribute that silently enforced an 8–16 character limit, contradicting the visible guidance. The browser blocked submission before the JavaScript could even validate it. Because no error was displayed, users faced an active Continue button that did absolutely nothing.
This is a classic example of redundant systems fighting each other—HTML validation failed while JS validation passed. Neither surfaced feedback, leaving users stranded.

3. The illusion of progress
Even after the password issue, the Continue button stayed clickable. No feedback, no visual state, no message. This violates a basic UX principle: visibility of system status. The interface implied readiness, but the system had already blocked the action. A dead button like this doesn’t just fail a task—it undermines user trust.

4. No recovery or clarity
Repeated retries triggered a vague “limit reached” lockout message. No timer, no next steps, no clarity. Even successful attempts contradicted themselves, displaying “Account already exists” before logging me in anyway. This lack of predictable flow design left users guessing what actually happened.

UX Diagnosis

This wasn’t a minor glitch—it was a breakdown of design communication and validation alignment. The product violated fundamental UX principles:

• Consistency and standards: Different flows followed different rules.

• Visibility of system status: The interface gave no feedback when blocked.

• Error prevention and recovery: Validation layers conflicted, and no corrective guidance was offered.

A unified validation strategy and proper error surfacing would have prevented all of this. Great UX design doesn’t just decorate workflows—it anticipates failure, communicates clearly, and prevents dead ends.

Technical Context (Brief)

• HTML pattern contained a malformed regex that caused invalid browser-level validation.

• Form used action="JavaScript:void(0);", suppressing normal submissions and browser feedback.

• Backend (Azure B2C) intermittently lost CSRF tokens, leading to 400 errors.

These engineering issues are common—but good UX could have mitigated them through clear feedback, consistent error handling, and redundant recovery options.

Takeaway

This experience illustrates how easily a flawed UX implementation can block users from performing a basic, business-critical action. Inconsistency between visible and hidden validation logic turned a simple signup into a dead-end maze.

Lesson: The best digital experiences anticipate imperfection. They make errors visible, states clear, and recovery simple. A silent failure isn’t just bad code—it’s bad design.

Note: The findings in this study were privately shared with the organization as part of the application process to help their design and engineering teams identify and correct these usability issues.