A Client Portal in 13 Weeks
A team of three, a fixed date, and an AI-accelerated delivery pipeline
Overview
Endowments, foundations, and healthcare systems hire the client to run their investment office entirely, handing over decisions most institutions would rather keep in-house. Their client-facing portal ran on a popular file sharing application, and fewer than 10% of client users actively logged in. Every advisor organized materials their own way, so a client's experience depended entirely on who staffed the relationship, and the firm carried the entire access-control burden for every external user of every client. I was the product consultant on a three-person team that delivered a production replacement in thirteen weeks, to a fixed pilot date that never moved.
Role
Product Consultant
Scope
13 weeks to a fixed pilot date; team of three, a product consultant, a lead developer, and a front-end developer
Tools
Figma, Storybook, GitHub, Claude
Approach
Problem Statement
The firm needed a client experience, not a document repository. Every advisor filed and named materials their own way, so two clients of the same firm could have completely different experiences depending on who staffed them. The firm also owned access-control for every external user of every client, and only found out someone had left a client organization if somebody happened to mention it. Prospects were asking to see the portal and marketing wanted to show it, but what existed didn't reflect the quality of the firm behind it.
Goals
- Standardize how every advisor organizes and delivers client materials, so the experience stops depending on who staffs the relationship
- Give the firm a portal it would be proud to put in front of a prospect
- Move access-control risk for external users off the firm and onto identity systems the client organizations already own
- Hit a fixed 13-week pilot date with a three-person team
Process
We treated the pre-contract brief as a hypothesis: real conversations with the people who do the work refined the identity provider, the data architecture, the permission model, and the compliance retention rules well beyond what any brief could specify going in. That's how we found the real document structure: the people who file and retrieve these documents every day pointed us toward a fixed set of centrally controlled categories with tags on top, instead of the folders everyone assumed going in.
Every one of those findings went into a decision log, in the open, naming the alternative that was ruled out and who made the call, so nothing got re-litigated once it was settled. That's what let research run the entire length of the engagement instead of stalling the build: a finding didn't have to wait for a formal handoff to matter, it just had to get logged.
- Continuous Research
- Decision Log
- Component Library
- AI-Accelerated Tickets
- Automated Code Checks
- Usability Testing
“AI went where its work could be verified. People went where it could not.”Ryan Wilson
The AI pipeline we built during this engagement is what let the team move fast without cutting corners on judgment. A hand sketch became a native, editable flow diagram, a validated flow became a wireframe, a wireframe became a click-through prototype anyone could test before a line of production code existed. We built the components in Figma first, accurate down to the token, then pointed Claude Code at them: the shared library and its Storybook documentation came together in about three days, then Claude Code turned that library into the entire production front end in twelve hours. What became the practice's standard for doing this kind of work came out of figuring it out here first.
Findings
The more the team learned about how the firm actually worked, the more complex the real problem turned out to be, and the AI pipeline was what let the team stay on top of that complexity without losing the delivery clock. The compliance team's retention rules in week two, a fixed-year SEC floor, a longer business-policy floor, and soft-delete only across all data, reshaped the data model days after the requirement was set, not weeks. An operations stakeholder's call that external "read" access had to include download moved from decision to shipped feature the same way.
The same speed showed up in the build itself: the shared component library came together in about three days, and the entire production front end from that library in twelve hours. In usability testing, running every task cold with no training doubled each session as that participant's first-day onboarding, so a single session could produce both a usability finding and a productive user.
Solution
The new portal gives every client the same experience, no longer dependent on who happens to manage the relationship, with materials organized the same way for everyone instead of one structure per advisor. We framed the solution directly with the people who'd use it, usability tested it before launch, iterated on what we found, and delivered it on time to a stakeholder and a set of users who were genuinely happy with the result.
“AI is a tool. We stay in control. We review the content. We stay aware of the product. This is 100% human work with AI support to speed us up. And our expertise is the prerequisite.”Ryan Wilson
Impact
Results
- Launched on time, to a fixed pilot date, with a team of three
- 8 feature areas live in production, including sign-in through each client's own organization, per-client document isolation, and full document management
- 92 decisions logged with reasoning and attribution; 46 open questions tracked, 44 driven to documented resolution
- A 59-component library with 137 Storybook stories behind 128 unit test files, fully reusable and ready to expand for the firm's future features
Achievements
- Hit a fixed delivery date with a three-person team by building the delivery pipeline itself, not just the product
- Translated a brand refresh into a governed token system so a rebrand stays a config change, not a project
- Ran a research and usability-testing program across six client functions concurrently with an active build
- Kept a working, auditable decision record that survived a team transition with no formal handoff meeting
- Built a reusable AI methodology that now helps the rest of my Product team adapt to modern tooling
Takeaways
What would I do differently?
If we could have gotten in front of this before the 13-week clock started, I'd have preferred to run a real discovery phase first instead of building the front end alongside it. Discovery doesn't block infrastructure, the identity architecture, the document security model, and the API foundation all had to be built regardless of what research turned up, and they were, starting in week two.
Those weeks were available for research whether or not we used them for it, and we spent some of them building screens against assumptions we hadn't yet tested. The date held because the team absorbed the rework, but a real discovery phase up front would have been the cheaper way to get the same result. Discovery is human work and it takes six weeks; no tool shortens that part. What the AI toolchain shortened was the cost of carrying a decision, once a person made it, into every artifact that has to reflect it.
How did I grow?
This project is where I learned the real value of living documentation kept current by AI, rather than a static wiki nobody updates. The client "brain" we built here, a version-controlled record of decisions, open questions, and context that stayed current through the engagement, taught me something I carry into how I run the whole practice now: an unresolved question with a named owner is worth more than a guess. Once every open question is visible in one place, nothing quietly turns into an assumption someone builds on without realizing it.
This project also sharpened where I'd let AI operate and where I wouldn't, and that distinction, green-zone work AI could transcribe or format, red-zone work only a person could originate, is the classification the whole practice now runs on. The clearest lesson came from something we got wrong first: we maintained a permission matrix by hand, and by week three it had quietly drifted from what the software actually did. The fix wasn't a smarter check, it was removing the hand-maintained copy entirely and generating the matrix from the code itself, so there was nothing left to drift. I didn't bring that discipline into this engagement, I built it here, under a deadline that didn't leave room to get it wrong twice, and it's the standard I've taught the rest of the practice since.
