Outlook Add-in
Users were stuck in a six-step copy-paste loop between Outlook and the CRM, and the existing sync engine failed without telling anyone. Three enterprise accounts were close to leaving. I proposed a modular Outlook add-in on top of the sync engine and sold the idea in two days with a clickable Figma prototype. I brought CRM capabilities into Outlook that gave sales an edge, and made sync visible so users can see what failed and fix it themselves.
Impact
Seats Retained
~160
across 3 at-risk enterprise accounts
Streamlined
6→0
Cross-app steps eliminated
- Product
- Maximizer Outlook Add-in
- Timeline
- Feb to Jun 2022 (first release)
- Status
- Live, updated continuously
- Role
- Solo Product Designer
- Platform
- Microsoft Outlook
- Team
- 1 designer, 2 PMs, 3 engineers

What I Shipped
01 Foundations
Consistency in UI
Adapted the web app's Fluent + Kendo Angular design system to Microsoft's sizing, components and interaction patterns for Outlook add-ins.
Modular Design
A host that lets us add, replace and expand modules without a redesign.
02 Design
3 Modes
Receiving Emails, Sending Emails, Calendar
4 Modules
Global Search, Contact Management, Save to Case & Opportunity, Save Email
Contact Detail Page
A rich detail page with 3 tabs, for a full view of each contact.
03 After the ICP Shift
AI Email Compose
Drafts replies from the client's investment data, life events (such as birthdays, or a child born or married) and past communications. I designed two versions with different access points and layouts. The second version shipped.
Financial Advisor Data
AUM and next KYC date shown on each contact.
Default Email Saving
All communications saved by default for compliance, which advisors need and sales users did not. Users can still opt out.

My Role
I owned design from discovery to final UI and designed around the limits of the Microsoft Graph API.
Modular Features: Designed the module system, so new user requests shipped on time without a redesign.
Adapted Design System: Reworked the web app's design system, which I created, to Microsoft's UI guidelines for add-ins.
Engineering Partnership: Worked closely with engineering to fit designs to technical limits under tight timelines.
Why It Was Time to Change
The first attempt to sync Outlook emails to Maximizer was a sync engine that engineering built as a proof of concept. Most users could not install it; setup needed a technical person with patience. Once it was running, it gave no sign of what it was doing. Emails often failed to sync, with no error, so users could not trust that their client history was complete. Breakages went unfixed, and three large accounts were close to leaving. Removing it looked less risky than keeping it.
Discovery and Reframing
Discovery: Sizing the Problem
The Evidence: Support tickets and negative feedback on the user engagement board showed how big the problem was.
The Constraint: Users handle private client data, so we could not shadow them or record sessions.
The Workaround: We gathered structured feedback from account managers and team leads. They shared what their teams faced without exposing any client emails.
Reframing: From Redesign to Rescue
The Hidden Cost: Walking through the manual copy-paste workaround showed its real price. CRM timelines were incomplete, so teams could not trust their client history.
The Signal: Teams kept using the broken tool. Demand was high, even though the proof of concept did not meet basic standards.
The Shift: The question changed from "Can we design a better Add-in?" to "What does it take to ship a stable MVP that users trust every day, before we lose these accounts?"
The Deadline: Leadership needed a direction within two days. Without one, engineering would patch the old proof of concept and ship it as it was.
Decision: A Modular Host, Proven in Two Days
The Proposal: Instead of patching the old proof of concept, I proposed a modular "server rack" model: one stable host, with features added as separate modules.
The Proof: Within the two-day window, I designed the rack and one module, and made a clickable Figma prototype to show it working. The module came from the PM's own wish list: look up a person and see if they are in Maximizer. If yes, see their details; if not, add them. I also showed how future features slot into the rack.
Engineering-Friendly: The plan kept engineering's work instead of replacing it. Their sync engine stayed, and their proof of concept was made stable, not thrown away. I asked them to expose status flags so users could see what was happening. For the MVP: sync in progress, sync failed, and disconnected.
The Decision: Leadership approved it easily, because it kept engineering's work and fit the same timeline as the patch. It was also ready for future features. The PM, the developers and the users were all happy with the result.


Goals
Business
- Retain Key Accounts: Keep three enterprise accounts that were at risk of leaving.
- Strengthen Competitive Differentiation: Give the sales team a feature that stands out against HubSpot and Salesforce.
Product Design
Primary: Earn Daily Trust
- Transparent Sync: Show users what synced, what failed, and how to fix it.
- Seamless Workflow: Eliminate the copy-paste loop between Outlook and the CRM.
- Native Experience: Follow Microsoft's add-in guidelines, so the product feels like part of Outlook.
- Scalable Foundation: Design a modular shell that absorbs new features without a redesign.
Next: Build Competitive Advantage
- Full CRM Work in Outlook: Let users manage client records, tasks, notes and deals without leaving Outlook, where HubSpot and Salesforce offer less.
- Save Email to Any Record Type: Let users save any email to any record type in the database, for example opportunities and cases, not only to a contact.
- AI Email Compose: Draft replies from client data (now shipped).
Product Considerations
Work Within Our Architecture: The only new API was the sync status flags. Other features used existing APIs. For example, AUM already existed in the web app, and I designed where it shows in the Add-in. Harder features needed fewer, smarter API calls. Engineering had rules that could not change, and I designed within them so users still got a smooth experience.
Work Within Microsoft's Limits: Design around what the Microsoft add-in structure allows, and treat those limits as fixed.
My Approach
Meet Users in Outlook: Designed the CRM experience inside the email client users already worked in.
For example, Save to Case & Opportunity and Save Email appear in the reading pane, so users never leave the message.
Three Modes, One Shell: Designed the Add-in around three modes: Receiving Emails, Sending Emails and Calendar. Each mode shows only the tools that fit it, instead of one crowded panel.
For example, open a meeting someone invited you to. Calendar mode shows which attendees are in your CRM and what you know about them. You can add missing attendees to the CRM, or add CRM contacts to the meeting. The agenda and related notes are one click away.
Modular Expansion: Designed Global Search, Contact Management, Save to Case & Opportunity and Save Email as separate modules, so each could ship and grow without changing the host.
For example, new use cases requested mid-cycle shipped as module updates, not as a redesign.
Fill the Record for the User: An email arrives with 10 recipients. Contact Management shows at a glance who is already in Maximizer, and as what record type. Anyone missing can be added fast, as any record type. Most of the time the user types nothing: a scraper looks up the company from the email domain, and a parser pulls the family name from the address. Family name is the main required field for most firms, so Save is available right away, and the user can complete the record later. Both run silently and are live.
For example, in dogfooding it felt like magic to some users, and an older teammate flagged it. I added a small pill showing that AI filled the field, and after release an in-app pop-up (Userflow) explained it.
Native Look and Feel: Followed Microsoft's sizing, density and interaction rules for add-ins.
For example, component sizes and focus states match Outlook, so the Add-in feels like part of Outlook, not a separate app.

Spotlight: Making Sync Visible
The Problem: A CSV import runs once, while the user watches it. Outlook sync is different. It runs in the background, every day or several times a day, and the user never sees it. The old proof of concept failed silently, so users could not tell whether their emails had reached the CRM.
The Questions Every User Needed Answered:
- Is my data in sync right now?
- Did the last sync go well?
- Which records failed, and why?
- How do I fix them?
Four Ways the Add-in Shows Sync Status:
- In Outlook: a large message with an action button when there is a problem. The button fixes it, or jumps to where it can be fixed.
- Status pill: connected or not, and if connected, syncing or idle.
- Sync History page: when each sync ran and what happened, with a high-visibility banner that says what the problem is and how to solve it.
- Contact table rows: each contact that failed to sync says why.
One Pattern, Three Uses: I applied the same model to the web app's CSV import and to data integrations, so users learn it once and recognize it everywhere.


Research and Validation
The Question: Should the new search open as a full page or as a large dropdown?
The Test: Two groups of 5 users with the same job each got one version for 10 days. Everyone else stayed on the old search.
What We Measured: Time on first use, then whether time dropped or use grew over the following days.
The Result: Use grew at almost the same rate in both. The dropdown got faster over time, which showed it needed learning. The full page was clear from the first use.
The Decision: We shipped the full page to everyone, because users understood it with no learning needed.
Changing ICP Focus
In late 2024, Maximizer changed its ideal customer profile (ICP) to financial advisors and insurance firms. The Add-in had to use their terms and support their compliance duties.
User Personas
| Persona | Primary ObjectiveThe "Job" | StrategyUX Focus |
|---|---|---|
| Manager | Trust that data the team generates in Outlook actually lands in the CRM, so pipeline and activity reports reflect reality. | Data confidence. Less friction for advisors and assistants means cleaner CRM data and reports that reflect reality. |
| Advisor | Stay focused on the client conversation: log communications, track in-progress deals, draft informed outgoing emails without leaving Outlook. | Fewer app switches. Show the right CRM data next to the email, and use AI to draft emails from client data, all in the side panel. |
| Assistant | Keep CRM records accurate: capture emails, schedule follow-ups, manage tasks directly from the inbox without toggling systems. | Speed and fewer errors at volume. Fast creating and editing of notes, meetings, tasks and deals, with bulk actions and inline validation. |
My New Approach
Match the New ICP: Kept the terms and KPIs that still fit, and replaced the ones that did not.
For example, replaced "Open Opportunity" with AUM, and added the next KYC date to each contact's details.
Support Compliance: Financial advisors have many legal duties around client records. The Add-in now supports those duties, instead of leaving them all to the advisor.
For example, email capture changed from optional saving to saving all communications by default, with an option to opt out.
AI Email Compose: Moved AI drafts from sales data (deal history) to advisor data.
Outcomes and Impact
Shipped to keep at-risk enterprise seats and end the copy-paste loop between Outlook and the CRM.
Seats Retained
~160
across 3 at-risk enterprise accounts
Streamlined
6→0
Cross-app steps eliminated
The Add-in kept roughly 160 seats across three at-risk enterprise accounts and removed the six-step copy-paste loop, so users work from one place.
Sync still fails sometimes. Users now see why and fix it themselves, so sync-failure calls stopped. They see which side failed (Microsoft or Maximizer) and the automatic retries in Sync History. When a token expires, a large banner asks them to re-enter credentials. It takes 2 clicks to see what went wrong and 1 more to reconnect, and the Add-in never disconnects to the point of reinstalling.
Sales now uses the Add-in to sell seats, because it gives Maximizer an edge over HubSpot and Salesforce inside Outlook.
Reflection
Show It, Don't Argue It
I was new and had little influence. A working prototype did more than any argument. When people can see an idea running, the decision gets easier.
Make Quality Fit the Deadline
Leadership needed speed. I did not ask for more time. I showed that a modular design fit the same timeline as a quick patch.
Make Failure Visible
Even if something broke, users could see it. Sync status and sync history turned a black box into something a person could read and fix.
Build the Frame, Then the Features
Years later, the Add-in still runs on the same frame. Each module can be replaced, and new features fit in without crowding the panel. Engineering became a long-term partner, and when I asked for data to solve user problems, they gave more than I asked for.
Next Case Study