Summary
Enterprise clients had no way to self-serve. Every request—from pulling a report to updating a contact—went through a support ticket. This created a backlog that frustrated clients and consumed the CS team. I led the product effort to build a self-service portal from scratch: discovery, scoping, engineering collaboration, and launch.
Headline result: Support ticket volume dropped 35% in the first 90 days. Client satisfaction scores for the portal segment rose by 18 points.
Context
The company’s product had been built for a world where every client had a dedicated account manager. That model worked at 50 clients. At 200+, it was breaking. The CS team was spending 40% of their time on requests that should have been self-service—password resets, usage reports, invoice downloads, user management.
Leadership had tried to address this twice before, both times shelving the effort after discovery. My mandate was to get something live.
The Problem
Three layers:
- Client friction. Clients submitted tickets for routine tasks. Average response time was 24 hours. Enterprise clients found this unacceptable.
- CS capacity. The team was at capacity on low-value work, leaving little bandwidth for the strategic account management that actually drives retention.
- Organizational risk. Without self-service infrastructure, the company couldn’t scale its client base without linearly scaling CS headcount.
Previous attempts had failed because the scope kept expanding. The team tried to build everything at once and ended up building nothing.
My Role
I owned the product from first principles:
- Ran 22 client interviews to identify the top 10 most-requested self-service tasks
- Defined the MVP scope and wrote the product brief
- Worked with engineering (team of 4) to define the technical approach
- Ran weekly sprint reviews and managed the roadmap against a hard launch date
- Collaborated with CS, Design, and Legal to get the portal through internal review
- Defined success metrics and owned the post-launch analysis
Approach & Key Decisions
Scope is the enemy. The previous attempts failed because the scope was unbounded. My first week was spent building a simple prioritization matrix: frequency of request × CS time cost × client frustration rating. This surfaced a clear top 5. We built those five things, nothing else.
Interview clients, not internal stakeholders. The CS team had strong opinions about what clients wanted. Those opinions were partially right and partially projection. The interviews revealed that usage reporting—which CS had rated low priority—was the single most-requested feature. We moved it to must-have.
Constraints as product strategy. Engineering had capacity for a 4-month build at most. I used that constraint to enforce discipline: every scope addition required dropping something else. This kept the project moving and prevented the “one more thing” failures that killed previous efforts.
Soft launch to a cohort. Rather than a big-bang release, we launched to 20 clients first—a mix of enthusiastic early adopters and skeptical power users. Their feedback drove 6 weeks of polish before the full rollout. This also gave CS time to update their workflows.
Outcome & Results
| Metric | Target | Achieved |
|---|---|---|
| Launch timeline | 5 months | 4 months |
| Support ticket reduction (90 days) | 25% | 35% |
| Client activation rate (day 30) | 60% | 74% |
| CS satisfaction with portal | — | 8.4/10 |
| Client CSAT for portal interactions | — | +18 pts vs. ticket channel |
The portal also became a sales asset. The sales team began including a portal demo in enterprise discovery calls. It closed two deals where clients had been comparing us to a competitor with a more modern interface.
Key Lessons
The scope conversation is the most important product conversation. Getting alignment on what the MVP would NOT include was harder than any technical problem—and more important.
Clients know what they want to do, not what they want to build. The interviews surfaced jobs-to-be-done that internal stakeholders had missed or underweighted. Always go to the source.
A phased launch is worth the coordination overhead. The cohort approach added complexity, but the feedback we got was worth far more than a clean big-bang release. We shipped a better product because of it.