Overview

The client needed a task manager module for our mobile app to help employees organize and complete daily tasks more efficiently. While the initial ask was a simple to-do list, the long-term goal was to support more complex workflows like recurring tasks, team assignments, and tracking.

I led UX research, design, prototyping, testing, and documentation. Despite unclear requirements and shifting priorities, I delivered a tested MVP and helped lay the groundwork for internal process improvements like a design system and better developer handoff.

The Challenge

The project was challenging from the outset. Stakeholders declined user interviews, stating they wanted a design first and then we'd discuss the next steps. This meant starting the design without access to user needs, workflows, or technological context. To add to the complexity:

• We had no design system or component library at this point
• Many UI elements in the live app were deprecated or undocumented.
• The UI had to be simple enough to function as a module of a larger solution, something dedicated task management applications do not have to worry about.
• Communication with the client was managed by a project manager who excluded design from key decisions.
• Late-stage scope creep transformed the project from a module into a full-featured task management platform.

Despite all of this, I focused on grounding the design in research, iterative validation, and user experience best practices.

Process

Research & Benchmarking

Since I couldn’t interview end-users, I conducted a competitive analysis of tools like Trello, Monday, Any.do, and Microsoft To Do. I mapped out common features, interaction patterns, and core use cases to understand the industry standard and avoid overcomplicating the MVP.

I worked with the PM to define an initial feature set centered around:

• Task lists (one-time or recurring)
• Completion and block states
• Manager and user roles
• Lightweight flows optimized for mobile use

Wireframing & Scoping

This was my first project at the company, and I quickly ran into inconsistencies across existing modules. Since we didn't have a design system or a component library, I had to replicate UI elements based on screenshots I took while exploring the app. I found out that our live app featured UI elements that were either deprecated and were replaced by slightly changed versions in some modules (but not others), or the elements were custom created for specific clients.

Since the Task Management module was a big depearture from the current content of our app, it became clear that existing UI elements and interaction patterns will not be sufficient in the long run. This prompted a key conversation with developers and project management: could we introduce new patterns? I argued for modern interaction design—bottom sheets for quick content previews, floating action buttons for task creation, and gesture-based task completion. These improvements were approved after discussion, and I refined the wireframes accordingly.

High-Fidelity Design & MVP

With the wireframes validated, I built the MVP prototype in Figma. Core flows included:

1. Managers creating task lists
2. Managers adding tasks
3. Users marking tasks as complete or blocked

While the MVP was functional, it lacked deletion controls and reminders—small issues that were resolved in a quick iteration. The client approved the design and greenlit further work.

Scope Creep & Redesign

Just before development began, the client introduced new requirements: notifications, due dates, employee groups, assignments, attachments, priorities, comments, tags, collaboration features, quick tasks, and task templates. I had less than one sprint to redesign and expand the module to account for these.

Some features were straightforward, while others introduced UX and technical complexity (e.g., recurring task deadlines). To prevent deadline conflicts, I proposed simplifying the recurrence logic and eliminating deadline dates in recurring lists. We documented and tracked features to be phased in later, and some (e.g., tags, templates) were ultimately shelved or delayed due to complexity.

User Testing

Even without access to end users, I performed usability testing internally:

1. Participants: Colleagues unfamiliar with the project
2. Method: Task-based testing in Figma on mobile devices
3. Focus: Task creation, interaction, and recurrence usability
4. Evaluation: I documented results in a matrix (correct/incorrect answers, pain points, suggestions)

I also A/B tested recurrence settings to determine the most intuitive configuration, leading to more streamlined task list creation.

All responses, notes, and observations gathered during user testing were arranged in a matrix to help visualize the usability and state of the MVP. This helped get an easier overview as to which aspect of the user flows needed to be addressed.

Feedback showed that the module was easy to understand across tech literacy levels, and iterative improvements followed each round of testing.

Final Outcome

The task manager module was implemented and adopted by the client. Key usage metrics showed daily engagement, and leadership saw potential for expanding task visibility across locations. While some features were pruned, we established a clear roadmap for future development.

However, implementation diverged in places due to uncommunicated changes from the PM, causing mismatches between design and build. This emphasized the importance of better alignment going forward.

Reflection

This project taught me how to design under ambiguity, advocate for scalable solutions, and stay user-focused even when removed from the user. It was a practical lesson in stakeholder management, UI consistency, and rapid iteration under pressure.

While the process wasn’t ideal, the outcome demonstrated that even in difficult situations, good UX practices can lead to solid solutions and organizational change.

The challenges I faced during this project ended up being a push for lasting change. I called attention to inefficiencies like unclear requirements, limited user access, and outdated components, and pushed for better ways of working. It set the stage for more structure, stronger collaboration, and a focus on user needs that carried over into future projects.