TaskFlow was engineered to solve the "coordination tax" that plagues high-growth technical teams. As projects scale, the time spent managing tasks often outweighs the time spent executing them. This project focused on building a logic-based automation engine that handles repetitive administrative work, allowing project leads to focus on high-level strategy and technical delivery.
My role
Product Designer
Led the end-to-end design of the automation engine, focusing on making complex logic triggers intuitive for non-technical project managers and team leads.
Project duration
6 months
Working team
3 backend engineers
2 frontend developers
1 product manager
1 lead designer
1 technical writer
2 content strategists
1 UX researcher
Project highlights
0%
0%
Fewer delays
0%
0%
Less effort
0+
0+
Active daily workflows
Architecture scalability award
The Problem
Operations leads at rapidly scaling software agencies were facing a critical bottleneck: "Work about work." Project managers were spending nearly a third of their day manually updating ticket statuses, reassigning developers, and notifying stakeholders across different platforms.
This fragmentation led to significant communication silos where developers were often working on outdated requirements because the central "source of truth" hadn't been updated. The manual nature of these updates created a high margin for human error, resulting in missed milestones and frustrated clients.
The goal was to build a system that acted as an invisible project assistant, automatically triggering the next step in a sequence based on real-time activity, thereby eliminating the need for constant manual oversight.
The Solution
We developed an "Event-Driven" automation layer that integrates directly into existing developer environments. Instead of asking teams to change how they work, TaskFlow listens for specific actions—like a code commit or a design approval—and automatically moves the project forward.
The interface was designed around a "Sequence Builder" that allows leads to drag and drop logic blocks. This visual approach made it possible for non-technical managers to build complex automation chains that previously would have required custom script writing and developer time.
The Vision
The long-term vision for TaskFlow was to move toward "Autonomous Project Management." We aimed to create a system that could not only move tasks but could also predict resource needs and suggest optimized timelines based on past team performance.
By removing the friction of administrative overhead, we wanted to empower teams to reach a state of deep work more consistently. We envisioned a world where the software handles the logistics of the project, leaving the creative and technical problem-solving entirely to the humans.
Phase 1: Research & Discovery
I shadowed four engineering managers to document every "non-coding" task they performed over a week. This research highlighted that 40% of their interruptions came from manual status requests, which directly informed our decision to prioritize the automated notification engine.
Automated Dependency Mapping
The engine identifies task relationships and automatically adjusts downstream timelines when a milestone is completed. This prevents communication gaps and ensures team alignment on shifting priorities.
Phase 2: Execution & Prototyping
During this phase, we iterated on the "Logic Canvas." We transitioned from a text-heavy rules engine to a visual flow-based interface. I built high-fidelity prototypes in Framer to ensure that connecting different automation "nodes" felt responsive and intuitive.
Visualizing the workflow
Replaced static task lists with an interactive timeline so leads can identify bottlenecks at a glance.
Streamlining automation triggers
Redesigned the logic builder with natural language inputs to make complex sequences easier to create.
Project Outcomes
0%
0%
Fewer delays
0%
0%
Less effort
0+
0+
Active daily workflows
Architecture scalability award
My Impact
As the Lead Product Designer, I was responsible for the end-to-end user experience, from initial stakeholder interviews to the final handoff of the React-based design system. I specifically focused on the "Automated Trigger" UI, ensuring that setting up complex API rules felt accessible even to non-technical users.
Learnings and challenges
What did we learn?
Flexibility is more valuable than rigid logic
Teams have very specific ways of working. Providing customizable templates rather than "one-size-fits-all" flows significantly increased the platform's adoption rate.
Feedback loops must be immediate
Users felt anxious when an automation ran in the background without a "Success" confirmation. Adding subtle haptic and visual cues for every triggered event improved user trust.
Challenges we faced
Managing complex logic loops required strict guardrails
It was easy for users to accidentally create "infinite loops" that crashed their project boards. We had to design a "Logic Validator" that flags contradictory rules before they are published.
Aligning cross-platform data proved difficult
Syncing data between different external tools created "race conditions" where two automations might trigger at once. We designed a prioritization queue to manage how events are processed.
Conclusion
TaskFlow proved that the best tools are those that stay out of the way. By automating the administrative "noise," we helped teams regain their focus. This project taught me that simplifying a complex technical process is as much about what you hide from the user as what you show them.
