Procore Integration
A full two-way project synchronization system between Efficiently and Procore.
I designed the integration end to end — connection logic, synchronization and every edge case — so users always understand what state their projects are in and what they can do next.
Efficiently
Efficiently is a platform for developers, collaborators and architects who create and manage collaborative construction projects together.
It brings project management, team communication and contractor data into one place. I've worked at Efficiently as a UX/UI designer for three years — from refining UI elements and page structure to independently designing complex platform features, validated with a focus group of active users. The Procore integration is one of them.
Context & Challenge
Procore is one of the largest enterprise platforms for construction project management, already used by a portion of our clients. Integrating was strategic: the market was moving toward similar integrations, and it was important for Efficiently not to put a barrier between the Procore that users already knew and ours.
The challenge was to design not a one-time connection but a full data synchronization system. Users can connect, disconnect, reconnect and remove projects at any time — and the system has to stay clear at every step.
The integration flow was designed end to end, covering connection logic, synchronization and all edge cases: disconnecting, reconnecting, editing and removing a project. Every state and transition was mapped in detail so the experience stayed clear and predictable, regardless of how or when a user chose to manage their connected projects.
After checking feasibility with the backend developers, we split the integration into two phases.
Procore Connection
Phase 1 is a one-time, company-level connection: the Company Admin / Account Owner links the Efficiently workspace to a Procore organization in the Admin Console via SSO authorization. Everything in Phase 2 builds on this state.
The flow covers the happy path and every exit from it: denied authorization keeps the account "Not connected", a failed integration raises an error snackbar with a retry, and the user is never left in an unclear state.
Project Status Logic
Beyond the main connection scenario, a key part of the work was a complete model of project states — what happens when a user pauses synchronization, restores it, or removes a project from the list entirely.
Connect & Sync Projects
Eight use cases for the day-to-day: connecting, syncing, editing and removing projects — each mapped as its own flow, with every state and exit accounted for.
Connect Projects
A compare fly-in panel: the user searches Procore companies and projects, matches them side by side with Efficiently projects, or creates a new Efficiently project from Procore data.
Sync Projects
Bulk “Sync Projects” or per-row sync. Rows show live progress, statuses and last sync time; a snackbar confirms completion. Failures keep the previous sync time and offer a retry.
Disconnect → Reconnect
Disconnect pauses syncing for a single project without losing the link. The confirmation states exactly which pair stops syncing and that reconnecting is one action away in the More menu.
Edit Project
Row more menu → “Edit project”. A field-level review compares each Procore value with the current Efficiently value. The user selects exactly what will apply before confirming.
Remove Project
A warning modal makes the consequence explicit: the row leaves the sync list, and the project becomes available for connection again.
Search & View Connected
Search across companies, Procore and Efficiently projects in the connected list; statuses stay visible, so the result is never ambiguous.
Hypothesis Validation
Efficiently is an early-stage product with a limited number of clients, so instead of quantitative metrics we rely on a focus group of active users. A/B test results will inform refinement of the flow ahead of a wider release.
Users understand the Procore connection process on the first try, without contacting support.
It is clear what data will be pulled from Procore before the user confirms the connection.
The difference between "Disconnected" and "Removed" is clear — what can be restored versus what starts over as a new action.
Users notice when a project disconnects from sync if it happened outside their own action.
Users have enough control over when and what gets synced — or expect more automation.
Reflection
The hardest part was designing a system where the user always understands what state their project is in and what actions are available, given that the data comes from an external system Efficiently does not control.
This work taught me to account for a wide range of input factors — from our platform and the external system alike. I adapted to information that kept updating as the work progressed and checked solutions against platform capabilities and backend feedback, so they stayed technically realistic, not just good-looking on paper.