Product type
- B2B
- Internal Operations Platform
- Web App
PULSE
About
Pulse is an internal operations platform built for an IT department of 30+ employees. Before the system existed, the team relied on Excel spreadsheets, email threads, and verbal agreements to manage tasks, track time, and coordinate projects — leading to delays, lack of visibility, and low accountability.
The platform was originally designed as an internal tool to support everyday workflows: project management, Agile processes, meeting coordination and time tracking. As the system matured, the team began considering it as a potential standalone SaaS product — which raised the bar for interface quality and scalability.
The system covers several core workspaces:
While the system contains some client data related to software purchases, its core function is optimizing internal team operations — task management, resource planning, Agile workflows, and employee engagement.
The platform was originally designed as an internal tool to support everyday workflows: project management, Agile processes, meeting coordination and time tracking. As the system matured, the team began considering it as a potential standalone SaaS product — which raised the bar for interface quality and scalability.
The system covers several core workspaces:
- Overview — high-level dashboards and team performance metrics
- Projects — project information, roadmaps, files, links, and team members
- Agile Board — Kanban board with task statuses and transitions
- Gantt Chart — project timelines and resource planning
- Calendar — meeting coordination and scheduling
- Log Hours — time tracking and time-logging reports
- Reports — exportable reports for managers, tech leads, and directors
- Personal dashboards — individual goals, development plans, and task history
- Goals — a dedicated page for company and team goals to boost engagement
While the system contains some client data related to software purchases, its core function is optimizing internal team operations — task management, resource planning, Agile workflows, and employee engagement.
My role
End-to-End Product Design & Design Lead — full design cycle, defined system logic together with the business analyst and product manager. During the support phase — handed the project over to another designer while retaining the role of key decision-maker for design solutions.
Work period
from scratch to implementation
The problem
The IT department had no centralized system for managing tasks, projects, or workload. All processes
were handled through a combination of Excel spreadsheets, email chains, and verbal agreements.
Before the redesign, the existing tooling was surprisingly minimal — most of the work happened in just
two areas: a Kanban board and a time-logging page. While this setup technically supported the basic
workflow, it was insufficient for a growing team.
This led to several critical issues:
The core issue wasn't a lack of functionality. The problem was that one interface was trying to serve multiple roles with completely different decision-making contexts.
were handled through a combination of Excel spreadsheets, email chains, and verbal agreements.
Before the redesign, the existing tooling was surprisingly minimal — most of the work happened in just
two areas: a Kanban board and a time-logging page. While this setup technically supported the basic
workflow, it was insufficient for a growing team.
This led to several critical issues:
- Project deadlines were frequently missed due to unclear task ownership
- Managers had no real-time visibility into team workload or project progress
- Time tracking was either inconsistent or completely absent
- Users struggled to locate important features; some bypassed the interface altogether or relied on external tools
- The same interface tried to serve executives, managers, and contributors — ignoring their fundamentally different needs
The core issue wasn't a lack of functionality. The problem was that one interface was trying to serve multiple roles with completely different decision-making contexts.
Business goals
- Eliminate project delays caused by unclear task ownership and resource conflicts
- Establish Agile workflows with measurable sprint velocity and progress tracking
- Provide management with data-driven reports on team performance, workload, and project health
- Increase team retention and engagement through transparent goal-setting and visible career development
- Build a scalable internal tool that can grow with the department
User goals
Through user research — interviews, observation, and workflow analysis — we identified that the differences between users were not simply about permissions or access levels. What truly separated them was the type of decisions they made inside the product.
The system serves three primary groups with fundamentally different workflows:
All three groups relied on the same product, yet their daily workflows looked completely different.
The system serves three primary groups with fundamentally different workflows:
- Executives and department heads — evaluate performance and project health. They need dashboards, metrics, and analytics to make strategic decisions without navigating operational details
- Product Managers, Tech Leads, and Team Leads — coordinate delivery. They create backlogs, work with Agile boards, plan timelines using Gantt charts, organize meetings, monitor whether team members log their hours, and generate reports
- Contributors (developers, designers, specialists) — execute the work. They receive tasks, move cards across the Kanban board, estimate work using story points, log hours, and access project documentation
All three groups relied on the same product, yet their daily workflows looked completely different.
The goal
Create a unified platform that brings transparency, accountability and structure to the team's daily work — while adapting the experience to how each role actually works, rather than forcing everyone into the same interface.
My contribution
- Full design of product logic, UX architecture, and interfaces
- Creation of a design system and component library from scratch
- Conducted user research: interviews with representatives from each role, observation of daily workflows, and analysis of friction points
- Developed role-based workspaces tailored to executives, managers, and contributors
- Designed a role-based access model, ensuring each user sees only what is relevant to their decision-making context
- Development of interactive prototypes and alignment with directors
- Set up Agile processes in the role of Scrum Master
- Supported product adoption: documentation, user guides, and checklists
- Handover to another designer with quality control at the support stage
Process
- Research & analysis — identified pain points of employees and managers through interviews and observation, studied existing Excel-based workflows, defined goals and constraints
- UX design — building user flows, sketches, wireframes, and interaction scenarios for each role
- Prototyping — interactive prototypes tested with real users from each role group, iterated based on feedback from directors and team leads
- UI design — built all key screens: tasks, projects, Kanban, goals, personal dashboard, reporting
- Implementation — collaborated with developers, tested, and launched into use
- QA & testing — checking quality of implementation
- Product support — handed over to another designer, implemented improvements based on feedback
Manager creates a task on the Agile Board, assigns it to a contributor
Contributor sees the task in their personal workspace, logs time inline as they work
Progress is visible in real time — Kanban status, burndown chart, Gantt timeline
Reports are generated automatically and accessible to managers and executives in their dashboards
After
Unified workflow
Pulse consolidates all steps into role-specific environments:
Pulse consolidates all steps into role-specific environments:
The task lifecycle was reduced from 6 scattered steps across multiple tools to 4 steps in one system, with real-time visibility replacing weekly reports and manual aggregation.
Manager writes a task description in an email or verbally during a meeting
Developer notes it in a personal spreadsheet or notebook
Progress updates happen in ad-hoc conversations or weekly status meetings
Time is logged manually in a shared Excel file (often at the end of the week, from memory)
Manager aggregates data from multiple Excel files into a report
Report is sent via email to directors
Before
Fragmented workflow
Before the redesign, the existing tooling barely reflected the differences between user roles. Most of the work happened in just two areas: a Kanban board and a time-logging page.
A typical task lifecycle — from assignment to completion and time reporting — involved multiple disconnected steps:
Before the redesign, the existing tooling barely reflected the differences between user roles. Most of the work happened in just two areas: a Kanban board and a time-logging page.
A typical task lifecycle — from assignment to completion and time reporting — involved multiple disconnected steps:
This process was slow, error-prone, and lacked real-time visibility. Some users bypassed the interface altogether, while others relied on external tools to complete tasks the system was supposed to support.
User Flow
Key design decisions
- Designed role-based dashboards so that developers, tech leads, and managers each see only the information relevant to their daily work — reducing noise and cognitive load
- Chose Kanban as the primary task view, with table and Gantt available as alternative views — matching how Agile teams naturally think about task progress
- Implemented inline time logging directly from task cards (one click to start/stop) instead of a separate time-tracking module — removing the biggest source of friction in the old workflow
- Created a dedicated Goals page that links individual tasks to team and company objectives — making daily work feel connected to a bigger picture
- Designed the notification system to surface only actionable items (assignments, blockers, deadlines) rather than all activity — avoiding alert fatigue
Role-based
design approach
design approach
One of the core design challenges was that the same product needed to serve users with fundamentally different goals. Through user research — interviews, observation, and workflow analysis — an important insight emerged: the differences between users were not about permissions or access levels. What truly separated them was the type of decisions they made inside the product.
Executives evaluated performance and project health. Managers coordinated work and delivery. Contributors focused on completing tasks.
Executives evaluated performance and project health. Managers coordinated work and delivery. Contributors focused on completing tasks.
3 UX principles
that guided the redesign
that guided the redesign
The restructuring followed three design principles commonly used in complex SaaS products:
Role-based entry points. Instead of a universal interface, the system guides each user toward areas most relevant to their responsibilities. Executives immediately encounter analytics and KPIs. Managers enter project coordination tools — backlogs, Agile boards, Gantt scheduling. Contributors land in task-focused
workspaces with their personal queue and time logging.
Progressive disclosure. The interface reveals additional detail only when it becomes relevant. Executives
see dashboards and performance metrics. Managers access planning tools and project structures.
Contributors interact with a simplified environment centered around tasks and statuses. No user is
overwhelmed with information they don't need.
Object-centered design. All users work with the same underlying data — projects, tasks, users, and time
logs. The difference is the perspective through which those objects are presented. Executives see project performance. Managers see planning structures and dependencies. Contributors see the actionable tasks
themselves.
Role-based entry points. Instead of a universal interface, the system guides each user toward areas most relevant to their responsibilities. Executives immediately encounter analytics and KPIs. Managers enter project coordination tools — backlogs, Agile boards, Gantt scheduling. Contributors land in task-focused
workspaces with their personal queue and time logging.
Progressive disclosure. The interface reveals additional detail only when it becomes relevant. Executives
see dashboards and performance metrics. Managers access planning tools and project structures.
Contributors interact with a simplified environment centered around tasks and statuses. No user is
overwhelmed with information they don't need.
Object-centered design. All users work with the same underlying data — projects, tasks, users, and time
logs. The difference is the perspective through which those objects are presented. Executives see project performance. Managers see planning structures and dependencies. Contributors see the actionable tasks
themselves.
Pulse stopped behaving like a single overloaded interface and instead became a collection of focused environments designed for different roles — built on top of the same underlying data model.
Design Trade-offs
- Showing all team tasks on one Kanban board improves transparency but can overwhelm individual contributors — solved by adding personal filtered views as the default
- Integrating Gantt charts adds powerful project planning capabilities but increases interface complexity — placed Gantt in the manager view only, keeping developer screens clean
- Mandatory time logging ensures data accuracy for reports but introduces daily friction — minimized by designing one-click inline logging from task cards
- Role-based access simplifies the interface per user but requires designing and maintaining multiple dashboard variants — managed through a shared component library
- A dedicated Goals page boosts engagement and strategic alignment but requires ongoing content maintenance from management — designed with simple editing tools to lower the barrier
Results
- Daily time logging reduced by approximately 80% — from ~15–20 minutes per person in Excel to ~2–5 minutes with inline tracking, saving the team an estimated 5+ hours per week collectively
- Status meetings reduced significantly — real-time Kanban and dashboard visibility replaced most weekly status update meetings, freeing up time for productive work
- The task lifecycle was streamlined from 6 fragmented steps (across email, spreadsheets, and verbal updates) to 4 steps in a unified interface
- User errors decreased — role-based workspaces ensured each user only interacts with relevant tools, reducing accidental mistakes and confusion
- Adopted by 30+ employees across executives, managers, and contributors — with role-based entry points driving high adoption across all user groups
- The system has been actively used for over 3 years and remains the primary team management tool, confirming long-term product-market fit
- A scalable design system was created from scratch, enabling consistent development of new features after handover to another designer
- Improved project planning quality — Gantt-based scheduling and resource visibility reduced missed deadlines and resource conflicts
This project taught me how to design for multiple user roles within a single product — not by toggling permissions, but by understanding the fundamentally different decisions each role makes.
Through user research I discovered that the difference between an executive, a manager, and a contributor is not what they can access — it's what they need to understand at a glance.
This insight led me to develop a role-based design approach built on three principles: role-based entry points, progressive disclosure, and object-centered design. I later documented this methodology in a dedicated article on Medium.
Leading the project as both designer and Scrum Master gave me a unique perspective on how process design and interface design are deeply interconnected. The decisions I made about Agile workflows
directly shaped the UX architecture, and vice versa.
The project also proved that internal tools deserve the same design rigor as external products — when people see their goals, track their progress, and feel ownership of their work, engagement and productivity follow naturally.
Through user research I discovered that the difference between an executive, a manager, and a contributor is not what they can access — it's what they need to understand at a glance.
This insight led me to develop a role-based design approach built on three principles: role-based entry points, progressive disclosure, and object-centered design. I later documented this methodology in a dedicated article on Medium.
Leading the project as both designer and Scrum Master gave me a unique perspective on how process design and interface design are deeply interconnected. The decisions I made about Agile workflows
directly shaped the UX architecture, and vice versa.
The project also proved that internal tools deserve the same design rigor as external products — when people see their goals, track their progress, and feel ownership of their work, engagement and productivity follow naturally.
MORE PROJECTS
