Improve real estate developer efficiency by helping them manage their project schedules.
Design and integrate the best solution into our product through user research, product strategy, UX, and visual design.
Dealpath is a workflow tool for real estate developers, allowing them to work collaboratively and efficiently on complex projects.
Real estate developers use Dealpath to manage their project workflows by coordinating tasks, assignments, and files across all their contractors and collaborators.
It's used by companies like WeWork, Cadre, and other leading real estate professionals to manage their development projects from start to finish.
We found that users were not engaging with our product as much in the beginning of each development project cycle.
This momentary dip in DAU & even WAU was not expected so we followed up with Customer Success to see if they understood why.
It turns out users were spending time building complex schedules at the beginning of each development project. This was a previously under-appreciated functionality for Dealpath, but as we learn in our user interviews, is beneficial to our customers.
Main use case
Managing a development project requires detailed scheduling and day to day tracking of progress. Catching delays early is most important to the workflow because these changes compound to quickly kill an ambitious project. From our interviews, we found four main pain points:
- Silo'd information: Project managers keep knowledge in disparate formats and channels like email, calendars, spreadsheets, and texts. This creates confusion and disorganization when it comes to coordinating task lists and timelines.
- Timing is critical: Not catching delays early-on kills a development project. Delays in the project schedule cascade, creating a snowball effect, so coordinating timelines is absolutely critical to successful projects.
- Dependency failures are common: Missing a task dependency is the most common cause of schedule delays. Delays most often occur due to not understanding complex task dependencies.
- Old software: Developers are hacking together their schedules with old software that isn't designed for them. They're using software like Microsoft Project and even Excel, which come with too many features and complicate their workflow.
- One unified schedule format & channel.
- Automatic notification of schedule changes.
- Dependency functionality and easy visualization.
- Automatic schedule generation at the beginning of each project.
- Increase retention by improving ROI for customers of Dealpath. (Reduce Customer Churn Rate by 10%)
- Drive upsell by adding additional value for users. (Increase Average Contract Value by 10%)
- Increased engagement in Dealpath. (Increase MAU by 10%)
- Increase virality by allowing external collaborators to work better with other teams. (Reduce Customer Acquisition Cost by 5%)
If we make developers more efficient, they'll take on more ambitious projects and become more profitable.
We believe we'll solve users problems by building:
If we succeed, we will hope to align them to business goals (and metrics of success):
The only limitation was that we needed to do this "cheaply", as a proof of concept and complete the dev time in two sprints. Once we have core functionality and can test it's success and build out more robust, follow-up features.
I started the design process by looking at important user tasks they needed to accomplish easily in order to be efficient. How users will interact with their schedules and what will it look like? Based on our findings, I sketched out and mocked up several layouts in an effort to help users easily answer:
- Is my project on track?
- What outstanding tasks need my attention?
- How long will this task take and when should I start thinking about it?
- Are people working on it?
- Do they have what they need?
- What tasks are due today?
Each of these questions are being asked by the project manager on a daily basis and should be easily accessible, but they're currently trapped in emails, spreadsheets, and across silo'd schedules. We wanted to explore how all of these workflows would interact together and if there was a better way to visualize them for day-to-day use. Here are some high-level layouts we explored.
Final Design & Iterations
We decided to move forward with the timeline UI based on feedback and learnings from our users. We found it still the best option for visualizing dependencies. From here we explored a series of ways we might integrate it into the product from a navigation standpoint, layout, and the flows. We explored several UI layouts like a full-screen timeline, a split screen task list and timeline, and different screen densities.
Solution & Results
After sharing these with a handful of customers, we learned what they valued most was the ability to see the task list alongside their timeline.
We felt confident that our v1 would solve many of the problems we defined in the beginning.
- Users can now use Dealpath schedules to build timelines, keeping them engaged and minimizing time consolidating formats.
- Users now have the ability to adapt quickly to schedule changes with complex dependency visualization and notifications.
- We can now share up-to-date schedules with all stake holders allowing them to update progress themselves.
As we monitor this feature through Mixpanel, Fullstory, and discussions with users, we know there are many improvements to be made:
- Ability to specify Start Date.
- More dependency types like: Multiple Parents.
- Increase screen density / more information on screen.
- Reverse cascading of dependencies, for example the ability to specify a Finish Date and automatically provide an estimated Start Date.
These are all great ideas and we're already starting to prioritize them in our roadmap! But as we all know, the process of refinement and learning is never over, and that makes it all worthwhile.