A design-leadership case study
Chase Connected Banking
When Chase ended screen-scraping, someone had to design the consented alternative. As Head of UX, Connected Banking — partnering with the Managing Director across multiple orgs — I led the experience for the ecosystem that replaced it: Chase as the authenticated, consented front door to banking data, for customers and the fintechs they rely on.
The shift
From scraped credentials to consented APIs.
Fintechs used to scrape customers' Chase credentials to get their data. We made Chase the secure, tokenized front door instead — and the industry followed.
This case study walks the consumer ecosystem — the consent shift and the products it enabled — then the platform and brand work behind it. The illustrative brand direction that reshaped how Chase speaks to customers closes the page.
At a glance
Role
Hands-on strategic design lead and people manager — directing the work across multiple teams and products, with design leads assigned under me, and leading the cross-functional team that delivered it
Scope
Consumer digital channels — Chase.com (Web) and Chase Mobile, across multiple lines of business
Also leading
Concurrently led Merchant Services, the API Portals program (a multi-brand developer platform — Chase and J.P. Morgan — plus the payments Dev Center), and the horizontal, cross-LOB Digital Channels org (IA, navigation & systems) — the org this work sat under
Skills
Design & content strategy · Systems thinking · Platform & CMS architecture · Governance · Agile delivery · Stakeholder alignment · People management
On confidentiality. This page shows the public-facing work and what it moved. The sensitive mechanics, internals, and enterprise tooling were done under NDA and are shown abstracted or recreated; figures are directional. Full detail on request.
At Connected Banking I was at the widest scope of my career: partnered with the Managing Director and covering his purview across the aggregation and API-management domains, I ran four teams at once — the consumer and mobile aggregation product, the Merchant Services developer portal (my team held the firm’s dev-portal / enterprise-design capability — the one group that could), and Chase’s internal/enterprise tools.
Export
Permission Chase account data to third-party apps — no password sharing.
Import
Permission and import held-away financial data into Chase.
Protection
Secure the data and infrastructure; move third parties off screen-scraping.
Dev Platform
Discover, publish, and consume APIs on the developer portal.
Products
A curated portfolio of APIs, demos, docs, and community for partners.
This case walks both halves — the customer-facing aggregation work in Part One, the developer-facing platform and tools in Part Two.
Customer-facing — the consented front door
The problem, the consent shift, and the two products that gave customers real control over their financial data.
The mandate
Screen-scraping had to end — without breaking the apps people rely on.
Across Digital Channels and the developer portals I was running, I took on a harder problem. Customers were handing their Chase username and password to third-party apps — which then, directly or through a middleware aggregator like Plaid, signed in as the customer and scraped far more than any one app needed: no consent, no visibility, no way to revoke. It was a standing security and legal risk — and Chase was the first major bank to commit to shutting it off on a schedule.
ReauthenticationThe design problem wasn't "turn it off." It was: replace scraping with something better — consented, secure, and seamless enough that the millions of customers using NerdWallet, Mint, QuickBooks and the rest never lost the connections they depended on.
The Security Center research came with me and shaped the ingress for what followed — see that case study for the deeper research story.
The shift
Consent became the front door.
Instead of handing over a password to be scraped, customers now authenticate through Chase, see exactly what they're granting, consent, and return to the third-party app — now powered by Chase APIs and tokenization, not stored credentials.
A secure, seamless hand-off
- They never share a username, password, or full account number.
- They choose which accounts to connect.
- They can disconnect anytime — access is theirs to grant and revoke.
The education screen does the heavy lifting: plain language, up front, before anyone taps "allow."

The in-app consent journey



The products
Giving customers real control over their financial data.
The consent rail made real products possible — one to bring outside data in, one to govern what Chase sends out. This is the meat of the work; everything after it supports these two.
External Accounts — bring it in
Connect outside savings, investments, and cards for one clear view and better advice. The ingress lived on the Chase homepage and in the Security Center. Straightforward by design: see everything, add an account, remove one.
Linked Apps — govern what goes out
See every third-party app with access, add one, and revoke the ones you forgot. The ingress came from the Security Center — the hub-and-spoke pattern from that work (Security Center case study below).




Simple screens, but the arc behind them — consent, security, and control — is the whole case. The rest of this page is how far it reached.
Education & brand — the influence win
Education had to be part of the product — so I pushed to change the brand.
For something as abstract as data-sharing, you don't bolt education on — you design it in, and that meant more content-heavy, explanatory pages. That need became the opening I'd been waiting for: a reason to finally push the illustrative visual language I'd been championing since the first team and product (the Dev Center). The research was blunt — generic stock photography and walls of legal copy didn't land — so I made the case for intentional, illustrative visual cues designed for the moment rather than borrowed, backed it with the data, and pushed it across both my digital-channel and developer spaces. After a couple of years of pushback, the org finally embraced it.
Before

A stock photo and a wall of legal terms. Correct, but cold — and no one read it.
After

Warm, illustrative, and consumable — the "why" told in three steps, on web and mobile alike. An example of the illustrative visual cues we were finally allowed to create.
The push landed beyond my own screens. The data on how poorly the generic imagery performed got the whole org to reconsider its branding — and they moved my creative director into the Head of Branding role to carry it forward. I lost her from my team, but I was genuinely happy for her, and it was the direction I'd wanted all along.
The full problem-solving and outcomes behind the aggregation work — the research, the mental-model findings, the shipped flows, and the results — are in the strategy deep dive →.
Developer-facing — the dev portals & enterprise tools
The engine behind it: the API platform and publishing pipeline, the enterprise tooling my team was pulled in to build, and the brand influence that followed.
The platform · three years of API work
The engine behind it: a custom API platform.
All of this innovation ran on the API work I'd led for three years — partnering with fintechs and building a custom developer portal in-house, because banking data was too sensitive for an off-the-shelf one. My focus here: the API publishing pipeline and its docs.
Marketing / overview doc
Interactive, build-ready docDocs came in three fidelities depending on how VIP the API was: a marketing overview, the Swagger spec, and — for the ones that mattered most — a hand-built interactive demo a developer could read and build against. That top tier, rebuilt in the final push, is what won the awards.
The real work was influence, not screens. It took a four-year push to convince legal and security that we could safely expose docs and products on the public site at all. And the case I made for content — that strong, scannable docs separating the business-owner overview from the developer's technical guides is what makes a great developer experience — is what earned my team the governance role: writing the external API docs and approving every publisher's API before it shipped. I managed the tech writers and their intake, so every partnered API met a product-grade bar.
The governance model, the maker-checker approval tool I designed, and the due-diligence behind going public are in the strategy deep dive →.
The final delivery · interactive docs







Impact & recognition
What the work moved.
Industry recognition
- DevPortal Awards — nominations for Best Accessible Developer Portal and Best Served API Business Model, driven by the interactive docs and the final brand work.
- Accessibility recognition (ACB / Disability Matters) for the portal's inclusive design.
- Akoya network + Plaid secure-data agreements — the consented-API model becoming the industry default.
- A model that scaled. I built the original one-application, two-storefront developer platform — J.P. Morgan and Chase; that model became the pattern the firm scaled into a multi-brand developer ecosystem, with Payments and Private Bank portals following.
The full awards, platform metrics, and brand story live in their own deep dives — API Portals → Branding the DX →
The legacy. The Linked Apps and data-sharing model I designed became the backbone of Chase's Security & Privacy Center, reaching 87M+ customers — the consented front door, now the default.
The strategy deep dive — password protected
There's more — the strategy and the internals.
The public page shows the finished work and what it moved. The deeper decisions, the sensitive mechanics, and the enterprise tooling are available on request.
What's behind the gate
- Aggregation internals — external & internal, how it actually worked
- The strategic due-diligence behind the API pipeline
- QuickBooks and the partner-specific integrations
- Enterprise tools — maker-checker, Platform Health, the admin suite
- The content-vs-UX leadership call and how governance was earned
- Rollout metrics & the round-after-round iteration
Password protected — reach out for access.
Next case study
Next →
Multi-Brand API Platform
The developer platform this API work ran on — one application, two storefronts (J.P. Morgan and Chase), and the publishing pipeline behind it.
Related cases