Write a PRD for Wealth Management

Build a portfolio-ready PRD for a unified ACATS transfer workflow.

Introduction

30 Second Summary

When a client wants to move their investments to a new firm, their advisor often has to juggle three disconnected systems just to complete the transfer. That fragmented workflow costs firms millions in call center volume and drives clients to abandon the process entirely.

In this project, you will build a complete product discovery and requirements package for redesigning a wealth management servicing workflow. You will map the current broken process, design the improved experience, write a professional PRD, create wireframes, and produce a stakeholder alignment one-pager.

What You'll Build

A portfolio-ready product discovery package documenting a unified ACATS transfer and account funding workflow for a wealth management servicing platform.

By the end of this project, you'll have:

AS-IS and TO-BE process flow diagrams in Miro showing the current fragmented advisor workflow and the redesigned unified experience.
A full PRD in Notion with a problem statement, user personas, user stories, acceptance criteria, RACI matrix, and compliance considerations.
Low-fidelity wireframes in Figma for the advisor-facing unified transfer dashboard, plus a stakeholder alignment one-pager exportable as a portfolio piece.
Secret Mission: add a data-driven RICE prioritization model and a Now/Next/Later roadmap view to your PRD.

Are there any prerequisites?

You will need free accounts for Notion, Miro, and Figma, plus a GitHub account and VS Code installed. Step 1 walks you through setting up each of these.

Set Up Your Workspace

Before you can map workflows and write requirements, you need a dedicated workspace for each deliverable.

In this step, you will create accounts and project spaces in Notion, Miro, and GitHub so that every artifact has a home from day one.

In this step, get ready to:

Create a Notion workspace for your PRD and stakeholder one-pager.
Create a Miro board for your process flow diagrams.
Set up a GitHub repository to version-control all documentation exports.

Create your Notion workspace

Notion is where you will write and publish your PRD and stakeholder alignment one-pager. Its free plan supports databases, embedded Figma frames, and PDF export.

Open your browser and navigate to notion.so.
Click Get Notion free.
Sign up using your email or Google account.
When prompted to name your workspace, enter WM Servicing Portfolio.
Select the Free plan if prompted to choose a plan.
Skip any onboarding tutorials or template suggestions by clicking Skip or closing the modal.

You should now see a blank Notion workspace with WM Servicing Portfolio displayed in the sidebar.

Don't see the workspace name in the sidebar?

Click Settings & members in the left sidebar, then select Settings. You can rename the workspace from there.

Help me rename my Notion workspace

Create your Miro board

Miro is a collaborative whiteboard tool used for process mapping and diagramming. You will use it to build your AS-IS and TO-BE workflow diagrams with swimlanes.

Open a new browser tab and navigate to miro.com.
Click Sign up free.
Create your account using your email or Google account.
Select the Free plan when prompted.
Once you land on the Miro dashboard, click the + New board button.
Name the board ACATS Transfer Workflow - Process Mapping.

You should see an empty white canvas with your board name displayed in the top-left corner.

Why Miro over Lucidchart?

Miro's free plan includes Flowchart shapes and swimlanes, which are sufficient for professional process diagrams. The dedicated BPMN shape pack requires a paid plan, but Flowchart shapes communicate the same logic and are recognizable to any hiring manager.

Miro is also a collaboration tool commonly used at large financial institutions, so referencing it in interviews demonstrates familiarity with enterprise tooling.

Can't find the New board button?

After signing up, Miro may walk you through an onboarding flow. Complete or skip each onboarding step until you reach your team dashboard. The + New board button appears in the top-right area of the dashboard.

Help me find where to create a new Miro board

Set up your GitHub repository and open VS Code

Your GitHub repository will store exported diagrams, wireframes, and PDFs so you can share your portfolio with a single link.

Open a new browser tab and navigate to github.com.
Sign in to your existing GitHub account.
Click the + icon in the top-right corner of the page.
Select New repository.
Enter wm-servicing-prd as the repository name.
Set the visibility to Public so it can serve as a portfolio piece.
Check the box for Add a README file.
Click Create repository.

You should see your new repository page with a README.md file listed.

Now clone the repository to your local machine and open it in VS Code.

On your repository page, click the green Code button.
Copy the HTTPS URL displayed in the dropdown.
Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
Type Terminal (macOS) or Command Prompt (Windows) and press Enter to open it.

Move to your Desktop by running this command:

cd ~/Desktop

Clone your repository by running this command:

git clone [[REPO_URL="https://github.com/YOUR_USERNAME/wm-servicing-prd.git"]]

Move into the cloned folder by running:

cd wm-servicing-prd

Open the folder in VS Code by running:

code .

VS Code should open with the wm-servicing-prd folder in the Explorer sidebar, showing your README.md file.

Seeing 'code' command not found?

You need to install the VS Code shell command. Open VS Code manually, press Cmd+Shift+P (macOS) or Ctrl+Shift+P (Windows), type Shell Command: Install 'code' command in PATH, and press Enter. Then try code . again in your terminal.

Help me open my project in VS Code from the terminal

Your workspace is ready. Next up, you will map the current-state ACATS transfer workflow in Miro, identifying exactly where advisors lose time and clients abandon the process.

Map the AS-IS Process Flow in Miro

Your workspace is ready. Now it's time to understand the problem you're solving by mapping the current-state workflow that frustrates advisors and drives clients to abandon transfers.

Today, an advisor who wants to onboard a client's assets faces three disconnected systems: one for initiating the ACATS transfer, a second for linking the client's bank account, and a third for updating the CRM. This "swivel-chair" behavior is the root cause of a 22-day onboarding cycle and constant call center escalations.

In this step, get ready to:

Research and document the current-state ACATS transfer workflow and its system handoffs.
Build the AS-IS process flow diagram in Miro with four swimlanes.
Annotate the diagram with quantitative pain points and export it to GitHub.

Research the current-state ACATS transfer workflow

Before you draw anything, you need a clear picture of how the ACATS transfer process works today and where the breakdowns happen.

What is ACATS?

ACATS (Automated Customer Account Transfer Service) is run by DTCC/NSCC and automates the transfer of assets between broker-dealers and banks. It supports equities, corporate/municipal bonds, UITs, mutual funds, options, annuities, and cash.

FINRA Rule 11870 governs this process. A standard transfer settles within approximately 6 business days, with the carrying firm required to validate within 3 business days.

The current workflow has two parallel paths that advisors must manage in separate systems. Here is how the ACATS transfer path works:

Client completes a Transfer Initiation Form (TIF) with the receiving firm, providing account number, registration type, and custodian name.
The receiving firm submits the transfer request to ACATS/NSCC, which assigns a control number.
The carrying (delivering) firm validates the request within 3 business days. They can accept, add assets, or reject.
If issues are not resolved within 2 business days, the transfer request is purged from ACATS and FINRA is notified.
Asset settlement completes in 3-6 business days after validation.

Simultaneously, the advisor must handle a completely separate workflow in a different system:

Bank account linking via ACH verification for recurring contributions (micro-deposit confirmation takes 2-3 business days).
Manual CRM update in a third system to record the transfer status and client communications.

Now identify the three system handoffs that force advisors into swivel-chair behavior:

Handoff 1: ACATS transfer system to bank-linking system (advisor switches platforms to set up ACH for the same client).
Handoff 2: Bank-linking system to CRM (advisor manually enters transfer status and notes).
Handoff 3: Call center escalation path (client calls to check status because there is no real-time visibility, advisor must check ACATS system separately).

What is swivel-chair behavior?

Swivel-chair refers to advisors constantly rotating between multiple disconnected systems to complete a single client task. Each system switch introduces manual data re-entry, context loss, and error risk. It's one of the most common productivity killers in wealth management servicing.

What is NIGO?

NIGO stands for "Not In Good Order." It's the industry term for forms or transfers rejected due to missing or incorrect information. Common causes include name/SSN mismatches, account type incompatibility, and non-eligible assets like certain annuities or proprietary products.

Build the AS-IS diagram in Miro with swimlanes

Now you'll translate your research into a visual process flow diagram. You'll use Miro's Flowchart shape pack (included free) to create horizontal swimlanes that show which actor owns each step of the workflow.

Open your ACATS Transfer Workflow - Process Mapping board in Miro.
Click the Templates icon in the left toolbar (it looks like a grid of squares).
Search for Swimlane in the template search bar.
Select the Swim Lane Diagram template to add it to your board.

No template? Use shapes instead

If you can't find the Swim Lane template, you can manually create swimlanes. Click the Shapes tool in the left toolbar, select rectangles, and draw four horizontal rows with labels on the left side.

Set up your four horizontal swimlanes with these labels from top to bottom:

Double-click the first lane label and type Client.
Label the second lane Advisor.
Label the third lane Operations/Middle Office.
Label the fourth lane ACATS/NSCC/Custodian.

Now add the process steps using flowchart shapes. Click the Shapes tool in the left toolbar and select shapes from the Flowchart category.

Place the following steps in the correct swimlanes, connecting them with arrows. Use rounded rectangles for process steps and diamonds for decision points:

In the Client lane, add a start oval labeled Client decides to transfer assets.
Add a process step in the Client lane: Completes Transfer Initiation Form (TIF) with receiving firm.
In the Advisor lane, add: Submits transfer request to ACATS/NSCC.
In the ACATS/NSCC/Custodian lane, add: ACATS assigns control number.
In the ACATS/NSCC/Custodian lane, add: Carrying firm validates (3 business days).
Add a decision diamond in the ACATS/NSCC/Custodian lane: Accepted or Rejected?.
From the "Accepted" path, add: Asset settlement (3-6 business days).
From the "Rejected" path, add: NIGO - Not In Good Order (purged if unresolved in 2 days).

Now add the separate bank-linking workflow. This is the second system the advisor must switch to:

In the Advisor lane, add a separate branch labeled Switch to bank-linking system (System 2). Draw a dashed line from the ACATS submission step to show this is a parallel task in a different platform.
Add: Initiate ACH verification for client bank account.
Add: Wait for micro-deposit confirmation (2-3 business days).
Add: Set up recurring contribution schedule.

Finally, add the manual CRM update and the call center escalation path:

In the Advisor lane, add another branch: Switch to CRM (System 3) - manually update transfer status.
In the Client lane, add: Calls advisor/call center: 'Where is my transfer?'.
In the Operations/Middle Office lane, add: Call center receives status inquiry - must check ACATS separately.
Draw an arrow from the call center step back to the Advisor lane showing the escalation loop.

Now mark the three swivel-chair handoff points visually. Use red-colored sticky notes or callout shapes to highlight each one:

Click the Sticky note tool in the left toolbar.
Change the sticky note color to red.
Place a red sticky note at each of the three system handoff points with these labels:

Why map pain points visually?

These red annotations make the business case immediately visible to any stakeholder who sees the diagram. A VP of Engineering or a compliance officer can look at this diagram and instantly understand where the process breaks down without reading a single page of documentation.

Can't find the Flowchart shapes?

The Flowchart shape pack is included on Miro's free plan. Click the Shapes tool (square icon in the left toolbar), then look for the "Flowchart" category in the shapes panel. If you only see basic shapes, click "More shapes" at the bottom to expand the full library.

Having trouble with your Miro board?

Annotate with quantitative pain points and export

Your diagram shows the workflow structure. Now you'll add the data that makes it compelling to decision-makers. Quantitative annotations transform a process diagram from "interesting" to "we need to fix this now."

Add a text box at the top of the diagram with a bold title: AS-IS: ACATS Transfer & Account Funding Workflow (Current State).
Click the Text tool (T icon in the left toolbar) and add three metric annotations near the relevant pain points on your diagram.

Place these three annotations near the most relevant areas of your diagram:

Near the bank-linking branch (where the parallel paths diverge), add: 23% client abandonment rate during simultaneous transfer + funding setup.
Near the call center escalation loop, add: Average 6.2 call center contacts per transfer.
Near the end of the overall flow (asset settlement), add: 22-day average onboarding cycle time.

Style your annotations for impact

Make the metric numbers large and bold (select the text, increase font size to 16-20pt). Use a contrasting color like orange or red for the numbers. This draws the eye to the data first.

Now export your completed AS-IS diagram as a PNG file:

Select all elements on your board by pressing Cmd+A (macOS) or Ctrl+A (Windows).
Click the ... (three dots) menu in the top-left corner of the board.
Select Export, then choose Export as image.
Select PNG format and click Export.
Rename the downloaded file to as-is-process-flow.png.

Push the exported image to your GitHub repository:

Open your wm-servicing-prd repository on GitHub.
Click Add file, then Upload files.
Drag your as-is-process-flow.png file into the upload area.
In the commit message field, type Add AS-IS process flow diagram.
Click Commit changes.

You should see as-is-process-flow.png listed in your repository's file list. Click on it to confirm the diagram renders correctly as a preview.

Export not available or image looks cut off?

Make sure all elements are selected before exporting. If some shapes are cut off in the export, zoom out on your board first, select everything with Cmd+A / Ctrl+A, and try exporting again.

Help me troubleshoot my Miro export or GitHub upload.

Your AS-IS diagram captures exactly where the current workflow breaks down. Next, you'll design the TO-BE unified workflow that eliminates these handoffs and collapses the 22-day cycle into a target of 8 days.

Design the TO-BE Unified Workflow

Your AS-IS diagram exposed the painful truth: advisors bounce between three disconnected systems just to complete a single transfer.

Now you'll design the future state. In this step, you'll create a TO-BE process flow that packages ACATS transfer initiation, bank account linking, and recurring contribution setup into one unified servicing event.

In this step, get ready to:

Create the TO-BE unified workflow diagram with a single advisor-initiated flow.
Map system integration points and parallel processing paths targeting an 8-day cycle.
Add decision gateways for exception handling and export the diagram to GitHub.

Create the unified advisor workflow diagram

The TO-BE diagram shows what the experience looks like when all three workflows collapse into a single servicing event. Instead of advisors switching between systems for transfer initiation, bank linking, and CRM updates, they complete everything from one screen.

Open your ACATS Transfer Workflow - Process Mapping board in Miro.
Scroll to an empty area to the right of your AS-IS diagram.
Add a text box with the title TO-BE: Unified Transfer & Funding Workflow.
Create four horizontal swimlanes using the Flowchart shape pack, matching the same lanes from your AS-IS diagram: Client, Advisor, Operations/Middle Office, and ACATS/NSCC/Custodian.

Now map the unified flow. The key difference from your AS-IS is that the advisor triggers everything from a single initiation point.

In the Advisor swimlane, add a start node labeled Advisor Initiates Unified Transfer.
Add three process boxes branching from that node: ACATS Transfer Submission, Instant Bank Account Verification (Plaid-style API), and Recurring Contribution Setup.
Connect all three branches to a synchronization point labeled Unified Servicing Event Created.
In the Client swimlane, add a process box labeled Real-Time Status Dashboard with a connector from the unified servicing event.
Add an annotation next to the dashboard node: Eliminates 'where is my transfer' calls (target: reduce 6.2 contacts to 1.5 per transfer).

Why instant account verification instead of ACH micro-deposits?

Traditional ACH verification sends two micro-deposits and waits 2-3 days for the client to confirm the amounts. Plaid-style instant verification lets the client authenticate their bank credentials in real time, shaving days off the onboarding cycle.

This is the same push-payment speed principle you'd recognize from real-time payment rails like RTP. The goal is eliminating wait states that cause clients to abandon the process.

Map system integration points and parallel processing paths

Your TO-BE diagram needs to show how the unified workflow connects to external systems. This is where you demonstrate architectural thinking about the integration layer that makes the unified experience possible.

In the ACATS/NSCC/Custodian swimlane, add process boxes for the following system integrations:
Add ACATS/NSCC Transfer Processing connected to the ACATS Transfer Submission branch from the advisor lane.
Add ACH/RTP Payment Rails connected to the Bank Account Verification branch.
In the Operations/Middle Office swimlane, add KYC/AML Verification Services triggered in parallel with the transfer submission.
Add Advisor CRM - Automatic Status Updates in the Advisor lane, receiving event-driven updates from all three processing paths.

Now show the parallel processing that compresses the timeline.

Draw parallel arrows from the Unified Servicing Event Created node showing three paths executing simultaneously: ACATS transfer processing, bank verification, and KYC/AML checks.
Add a timeline annotation along the bottom showing the compressed cycle: Day 1: Initiation + Instant Bank Verification, Day 1-3: ACATS Validation (parallel with KYC/AML), Day 3-8: Asset Settlement + Contribution Activation.
Add a bold annotation: Target: 8-day cycle (reduced from 22 days via parallel processing).

Why parallel processing cuts the cycle so dramatically

In the AS-IS flow, bank linking can't start until the ACATS transfer is confirmed, and CRM updates happen manually after everything else. The TO-BE flow starts all three workstreams on Day 1.

The 22-day cycle wasn't caused by 22 days of actual work. It was caused by sequential wait states. Eliminating those dependencies is the single biggest lever.

Add decision gateways for exception handling and export

Real-world transfers don't always go smoothly. Your TO-BE diagram needs to show how the system handles exceptions without routing everything back to the advisor's phone.

Add a diamond-shaped decision gateway after the ACATS/NSCC Transfer Processing node labeled Validation Pass?.
From the No path, add three exception branches:
Branch 1: NIGO Rejection - Auto-detect missing/incorrect fields, suggest resolution to advisor.
Branch 2: Name/Title Mismatch - Flag for advisor correction before ACATS purge deadline (2 business days).
Branch 3: Partial Transfer - Non-eligible assets identified, route to liquidation queue.
Add a separate decision gateway in the Operations/Middle Office lane after the KYC/AML check labeled Compliance Hold Required?.
From the Yes path, add a process box: Transfer suspended - Compliance review triggered for transfers above threshold.
Connect all exception resolution paths back to the main flow with a Resume Processing merge point.

What is NIGO?

NIGO stands for "Not In Good Order." It's the industry term for forms or transfers rejected due to missing or incorrect information. Think of it like a dispute resolution queue. The system auto-detects the issue and suggests a fix, rather than requiring manual investigation.

Why the 2-business-day purge deadline matters

If issues aren't resolved within 2 business days, ACATS purges the transfer request entirely and notifies FINRA. Your TO-BE design proactively flags name/title mismatches so the advisor can correct them before this hard deadline hits.

Your TO-BE diagram is complete. Time to export it.

Select all elements in your TO-BE diagram by drawing a selection box around them.
Click the ... (More) menu in the top-left toolbar.
Click Export, then select Save as image.
Choose PNG format and save the file as to-be-process-flow.png.

Now push the export to your GitHub repository.

Open your wm-servicing-prd repository on GitHub.
Click Add file, then Upload files.
Drag and drop to-be-process-flow.png into the upload area.
Enter the commit message Add TO-BE unified workflow diagram and click Commit changes.
Verify that your repository now shows both as-is-process-flow.png and to-be-process-flow.png in the file list.

Don't see the export option in Miro?

Make sure you've selected the diagram elements first. The export option only appears when content is selected. If you still don't see it, try right-clicking on your selection and choosing Export from the context menu.

help me export my Miro diagram as a PNG

You now have both the current pain and the future vision documented side by side. Next up, you'll translate this TO-BE workflow into a full PRD with user stories, acceptance criteria, and success metrics that bring the vision to life for stakeholders.

Write the PRD in Notion

Your process flow diagrams visualize the problem and the solution. Now you need to formalize everything into a Product Requirements Document that engineering, compliance, and leadership can act on.

A PRD is where the quantified pain points from your AS-IS mapping become measurable goals, and where your TO-BE workflow translates into user stories that a development team can estimate and build. In this step, you will create a publication-ready PRD in Notion that ties together your research, personas, user stories, and organizational constraints.

In this step, get ready to:

Create the PRD page with a quantified problem statement, user personas, and success metrics.
Write 8 user stories with acceptance criteria covering the full unified workflow.
Add a RACI matrix and constraints section covering FINRA, data privacy, and integration dependencies.

Create the PRD page with problem statement, personas, and goals

Notion's free PRD template gives you a professional structure out of the box. You will customize it with the specific sections a wealth management servicing initiative requires.

Open your WM Servicing Portfolio workspace in Notion.
Click + New page in the left sidebar.
In the new page, click Templates at the bottom of the empty page.
Search for PRD in the template gallery and select the Product Requirements Document template.
Rename the page title to PRD: Unified ACATS Transfer & Account Funding Workflow.

What is a PRD template in Notion?

Notion's PRD template pre-builds the standard structure product managers use: Context, Goals, Requirements, Constraints, Assumptions, and Dependencies. You will customize and extend these sections for wealth management servicing specifics.

Now populate the core PRD sections. Start with the Problem Statement.

Find or create a section heading called Problem Statement.
Write 2-3 paragraphs describing the current fragmented advisor workflow. Quantify the pain using the metrics from your AS-IS mapping: 23% client abandonment rate during simultaneous transfer and funding setup, 6.2 average call center contacts per transfer, and a 22-day average onboarding cycle.
Reference the "swivel-chair" behavior you documented: advisors switching between 3 disconnected systems (ACATS portal, bank-linking system, CRM) to complete a single client transfer.

Frame metrics as industry benchmarks

In interviews, describe these metrics as "based on industry benchmarks" rather than proprietary data. The 22-day onboarding average and 20-40 hours of staff time per household come from Celent and InsidePartners research on wealth management onboarding.

Create a User Personas section below the Problem Statement.
Add three persona cards with the following structure for each: Name/Role, Goals, Pain Points, and Key Tasks.

Your three personas are:

Wealth Advisor - Primary user who initiates transfers, links bank accounts, and manages client relationships. Their goal is to onboard new clients quickly without manual re-entry across systems.
Client - End customer transferring assets from a previous firm. Their goal is visibility into transfer progress without needing to call their advisor repeatedly.
Operations Analyst - Middle-office team member who handles exceptions, NIGO rejections, and manual reconciliation. Their goal is a clear exception queue with suggested resolution paths.

Create a Goals and Success Metrics section below User Personas.
Define three primary success metrics as measurable targets:

Reduce onboarding cycle time from 22 days to 8 days.
Reduce call center contacts per transfer from 6.2 to 1.5.
Increase transfer completion rate from 77% to 92%.

Why these specific targets?

The 8-day target comes from your TO-BE process mapping, where parallel processing paths (ACATS transfer + bank linking running simultaneously instead of sequentially) compress the timeline. The 1.5 call center contact target reflects the real-time status dashboard eliminating "where is my transfer" calls.

Write 8 user stories with acceptance criteria

User stories translate your TO-BE workflow into actionable requirements a development team can estimate and build. Each story follows the standard format: "As a [persona], I want [action] so that [benefit]."

Create a User Stories section in your PRD.
For each story, include: the user story statement, 3-5 acceptance criteria as checkboxes, and any dependencies on other stories.
Write the following 8 user stories:

Story 1: Advisor initiates unified transfer. "As a Wealth Advisor, I want to initiate an ACATS transfer, link a bank account, and schedule recurring contributions in a single workflow so that I don't need to switch between three systems."
Story 2: Client receives real-time status notifications. "As a Client, I want to receive automated notifications at each stage of my transfer so that I don't need to call my advisor to check progress."
Story 3: System auto-detects ACATS rejection reasons and suggests resolution. "As an Operations Analyst, I want the system to identify rejection reasons (name mismatch, SSN discrepancy, non-eligible assets) and suggest corrective actions so that I can resolve issues without research."
Story 4: Bank account verification completes inline. "As a Wealth Advisor, I want bank account verification to happen within the transfer initiation flow (via instant account verification) so that I don't need to switch to a separate system."
Story 5: Recurring contribution scheduled contingent on transfer settlement. "As a Wealth Advisor, I want to schedule recurring contributions during transfer initiation that auto-activate once the transfer settles so that the client's investment plan starts without a follow-up."
Story 6: Operations team receives exception queue for NIGO items. "As an Operations Analyst, I want a prioritized queue of Not In Good Order items with suggested fixes so that I can resolve exceptions in priority order."
Story 7: Compliance review triggered for transfers above threshold. "As a Compliance Officer, I want the system to automatically flag transfers above a dollar threshold for AML/KYC review so that regulatory requirements are met without manual monitoring."
Story 8: Advisor dashboard shows portfolio-in-transit with projected completion date. "As a Wealth Advisor, I want to see all in-flight transfers on a single dashboard with projected completion dates so that I can proactively communicate with clients."

What makes good acceptance criteria?

Each acceptance criterion should be testable and binary (pass/fail). For example, Story 1 might include: "Given the advisor completes all required fields, when they click Submit, then the system creates a single servicing event containing the ACATS transfer request, bank-link verification, and contribution schedule."

Write 3-5 acceptance criteria per story. Focus on the specific behavior, not implementation details.

Write acceptance criteria for each of your 8 user stories following the Given/When/Then format.

Stuck on acceptance criteria?

Look back at your TO-BE diagram in Miro. Each decision gateway and system integration point maps to at least one acceptance criterion. The exception handling paths (NIGO, partial transfers, compliance holds) are especially useful for defining edge-case criteria.

Help me write acceptance criteria for my user stories based on my TO-BE process flow.

Add the RACI matrix, constraints section, and export

A RACI matrix clarifies who is Responsible, Accountable, Consulted, and Informed for each deliverable. This prevents the "I thought you were handling that" conversations that derail cross-functional initiatives.

Create a RACI Matrix section in your PRD.
Add a table in Notion with rows for each major deliverable and columns for: Product, Technology, Operations, Legal, Compliance, and Marketing.
Fill in each cell with R (Responsible), A (Accountable), C (Consulted), or I (Informed).

Here are the major deliverables to include as rows in your RACI table:

Unified transfer workflow (API design and front-end).
Real-time status notification system.
ACATS/NSCC integration.
Bank-linking (instant account verification) integration.
Compliance review automation.
Client communication and advisor enablement materials.

Product owns the outcome, not the code

For the unified transfer workflow row, Product is typically A (Accountable for the outcome), Technology is R (Responsible for building it), Compliance is C (Consulted on regulatory constraints), and Marketing is I (Informed of timeline for enablement materials).

Next, document the constraints that will shape technical and business decisions.

Create a Constraints section below the RACI matrix.
Add a subsection for Regulatory: document that FINRA Rule 11870 governs the customer account transfer process. Note that if issues are not resolved within 2 business days, the transfer request is purged from ACATS and FINRA is notified.
Add a subsection for Data Privacy: document CCPA and GLBA requirements that govern financial data sharing. The bank-linking feature requires explicit client consent for sharing account data with third-party verification providers.
Add a subsection for Integration Dependencies: document dependency on DTCC/NSCC for ACATS processing, payment rails (ACH/RTP) for bank linking, and KYC/AML services for compliance checks.

Why does FINRA Rule 11870 matter here?

FINRA Rule 11870 establishes strict timelines for account transfers between broker-dealers. The carrying firm must validate or reject within 3 business days, and the total settlement window is approximately 6 business days. Your PRD's success metrics and system design must account for these regulatory timelines as hard constraints.

Finally, export your PRD for version control.

Click the ... menu in the top-right corner of your PRD page.
Select Export, then choose PDF.
Save the file as prd-unified-transfer-workflow.pdf.
Push the PDF to your wm-servicing-prd GitHub repository alongside your Miro exports.

Don't see the Export option?

Make sure you are clicking the ... menu at the page level (top-right corner), not a block-level menu. The export function only appears at the page level. If you still don't see it, try accessing the page from the sidebar and right-clicking for export options.

Help me export my Notion PRD page as a PDF.

Your PRD is now complete with a quantified problem statement, personas, success metrics, 8 user stories, a RACI matrix, and regulatory constraints. Next up, you will bring these requirements to life with low-fidelity wireframes in Figma that show exactly what the advisor-facing experience looks like.

Create Low-Fidelity Wireframes in Figma

Your PRD is solid. It quantifies the problem, maps personas, defines user stories, and names the constraints. Now it's time to make the solution tangible.

A PRD tells stakeholders what to build. Wireframes show them how it feels. In this step, you'll design three low-fidelity screens in Figma that translate your user stories into a concrete advisor-facing dashboard.

In this step, get ready to:

Design three wireframe screens for the unified transfer dashboard.
Link wireframes to specific user stories in your PRD.
Export and embed the wireframes in your Notion PRD and GitHub repository.

Design the three-screen wireframe set

Your wireframes will cover the three critical screens an advisor interacts with during a unified transfer. Each screen maps directly to user stories in your PRD.

Open Figma in your browser or desktop app.
Click New design file from your Figma home screen.
Rename the file to Advisor Unified Transfer Dashboard - Wireframes by double-clicking the file name in the top toolbar.

You'll create three frames (Figma's term for artboards), one per screen. All wireframes stay grayscale with no branding to keep the focus on layout and information hierarchy.

Screen 1: Initiate Transfer form

This screen combines three previously separate workflows into one form: ACATS transfer details, bank account linking, and recurring contribution setup.

Press F on your keyboard to activate the Frame tool.
In the right panel under Design, select Desktop and choose a 1440x1024 frame size.
Double-click the frame name in the left layers panel and rename it to Initiate Transfer.

Now build the form layout inside this frame. Structure it as a stepper with three collapsible sections so the advisor completes everything in one flow.

Press T to activate the Text tool.
Add a page header: Initiate Unified Transfer at the top of the frame using size 24, black (#000000).
Below the header, create a horizontal stepper showing three steps: 1. Transfer Details, 2. Link Bank Account, 3. Schedule Contributions. Use circles connected by lines to represent progression.
Use the Rectangle tool (R) to draw form field placeholders in a light gray (#E5E5E5) fill with dark gray (#333333) labels.
In the Transfer Details section, add labeled fields for: Client Name, Delivering Firm, Account Number, Transfer Type (Full/Partial), and Asset Selection (for partial transfers).
In the Link Bank Account section, add fields for: Routing Number, Account Number, and a button labeled Verify Instantly (indicating Plaid-style instant verification).
In the Schedule Contributions section, add fields for: Contribution Amount, Frequency (Monthly/Quarterly), and Start Date (after transfer settles).
Add a Submit Transfer button at the bottom using a dark gray (#333333) rectangle with white text.
Add an interaction annotation using a small text label in blue (#4A90D9): Maps to User Story 1: Advisor initiates unified transfer.

Why grayscale only?

Low-fidelity wireframes deliberately avoid color, branding, and polish. This keeps stakeholder feedback focused on information architecture and workflows, not visual design preferences.

When a VP of Engineering sees a grayscale wireframe, they critique the data flow. When they see a polished mockup, they critique the button color. You want the first conversation.

Screen 2: Transfer Status dashboard

This screen eliminates the 6.2 call center contacts per transfer by giving advisors real-time visibility into where each transfer sits in the ACATS pipeline.

Create a new 1440x1024 frame next to your first one.
Rename it to Transfer Status.
Add a page header: Transfer Status Dashboard at the top.
Create a progress tracker in the top section. Draw 5 circles connected by a horizontal line, labeled: Submitted, Validated, Assets Reviewed, In Settlement, Complete. Fill the first three circles dark gray to show progress.
Below the tracker, add a Portfolio in Transit section. Use a simple table with columns: Asset, Type, Value, Status. Add 3-4 placeholder rows with sample data.
Add a Projected Completion callout box on the right side showing an estimated date and day count.
Add a Bank Linking Status indicator below the portfolio table showing Verified with a checkmark icon.
Add the interaction annotation: Maps to User Story 2 (real-time status) and User Story 8 (portfolio-in-transit with projected completion).

What are ACATS status codes?

The real ACATS system uses technical status codes that mean nothing to advisors or clients. Your wireframe maps these codes to plain-language steps (Submitted, Validated, In Settlement, Complete) so anyone can understand transfer progress at a glance.

This is the same pattern behind package tracking. FedEx doesn't show you raw logistics codes. They show you "Out for delivery."

Screen 3: Exception Resolution queue

When an ACATS transfer gets rejected (name mismatch, ineligible assets, missing data), the industry calls this NIGO (Not In Good Order). This screen gives advisors a clear queue of issues with suggested resolutions instead of a cryptic rejection email.

Create a third 1440x1024 frame.
Rename it to Exception Resolution.
Add the page header: Exception Resolution Queue.
Create a table-style layout with columns: Client, Issue Type, Severity, Suggested Fix, Action.
Add 3 sample rows with realistic NIGO scenarios:
Add a Resolve button in the Action column for each row (dark gray rectangle, white text).
Add the interaction annotation: Maps to User Story 3 (auto-detect rejection reasons) and User Story 6 (operations exception queue).

Use auto-layout for clean alignment

Select your form fields or table rows, then press Shift+A to wrap them in an auto-layout container. This keeps spacing consistent and makes it easy to reorder elements later.

For reusable elements like buttons and form fields, select the element and press Cmd+Option+K (macOS) or Ctrl+Alt+K (Windows) to turn it into a reusable component.

Link wireframes to your PRD user stories

Wireframes without traceability to requirements are just drawings. Linking each screen to specific user stories shows hiring managers you think in systems, not just screens.

Review the interaction annotations you added to each screen. Confirm the mappings:
Open your PRD in Notion.
Navigate to each relevant user story in your PRD.
Add a note beneath each user story's acceptance criteria that says See wireframe: [Screen Name] to create the cross-reference.

Export wireframes and embed in your PRD

Your wireframes need to live in two places: embedded in the Notion PRD for stakeholder review, and in your GitHub repository as portfolio artifacts.

In Figma, click on the Initiate Transfer frame to select it.
Open the export panel in the right sidebar under the Export section (at the bottom of the Design tab).
Click + to add an export setting.
Set the format to PNG at 2x resolution.
Click Export Initiate Transfer and save as wireframe-initiate-transfer.png.
Repeat for the Transfer Status frame, saving as wireframe-transfer-status.png.
Repeat for the Exception Resolution frame, saving as wireframe-exception-resolution.png.

Now export a combined PDF for your LinkedIn portfolio.

Select all three frames by holding Cmd (macOS) or Ctrl (Windows) and clicking each frame.
In the Export section, change the format to PDF.
Click Export 3 layers and save as wireframes-advisor-dashboard.pdf.

Next, embed the wireframes in your Notion PRD.

Open your PRD page in Notion.
Scroll to the bottom of the document.
Type /heading2 and create a new section titled Design.
Below the heading, type /image and upload wireframe-initiate-transfer.png.
Add a caption below the image: Screen 1: Initiate Transfer - Maps to User Stories 1, 4, 5.
Repeat for wireframe-transfer-status.png with the caption Screen 2: Transfer Status - Maps to User Stories 2, 8.
Repeat for wireframe-exception-resolution.png with the caption Screen 3: Exception Resolution - Maps to User Stories 3, 6.

Finally, push all wireframe exports to your GitHub repository.

Open VS Code with your wm-servicing-prd repository.
Copy your four exported files (wireframe-initiate-transfer.png, wireframe-transfer-status.png, wireframe-exception-resolution.png, and wireframes-advisor-dashboard.pdf) into the repository folder.
Stage, commit, and push your changes by running these commands in the terminal:

git add .
git commit -m "Add wireframe exports for advisor unified transfer dashboard"
git push origin main

Verify the push succeeded by refreshing your repository on GitHub. You should see all four new files alongside your existing as-is-process-flow.png, to-be-process-flow.png, and prd-unified-transfer-workflow.pdf.

Images not embedding in Notion?

Make sure you're using /image and selecting Upload, not Embed link. The PNG files need to be uploaded directly from your computer.

If the images appear blurry, confirm you exported at 2x resolution in Figma.

Having trouble with the export or embed?

Your PRD now has visual substance. Stakeholders can see exactly what the advisor experience looks like, mapped back to the user stories they approved. Next up, you'll write the stakeholder alignment one-pager that brings Legal, Compliance, Technology, and Marketing together around this initiative.

Write the Stakeholder Alignment One-Pager

Your wireframes now give stakeholders something tangible to react to. But a VP Product Manager doesn't just hand over designs and hope for the best.

In this step, you'll create an executive-level stakeholder alignment document that proactively addresses concerns from Legal, Compliance, Technology, and Marketing. This is the artifact that gets a room of decision-makers to say "yes" in one meeting instead of three.

In this step, get ready to:

Structure a stakeholder alignment one-pager in Notion with Initiative Summary, Business Case, and Key Decisions.
Write stakeholder-specific sections addressing Legal, Compliance, Technology, and Marketing concerns.
Export the one-pager as PDF and push all project artifacts to GitHub with a professional README.

Create the one-pager page structure in Notion

A stakeholder alignment one-pager is different from a PRD. It's shorter, higher-level, and optimized for decision-making rather than implementation detail.

In your Notion workspace (WM Servicing Portfolio), click + New page in the left sidebar.
Title the page Stakeholder Alignment: Unified Transfer & Funding Workflow.
Select Empty page as the template (you'll build the structure manually for maximum control).

Now add the three core sections that every executive one-pager needs.

Type /heading 2 and create a heading called Initiative Summary.
Write exactly 2 sentences summarizing the initiative. For example: "Redesign the fragmented ACATS transfer and bank account linking workflow into a single advisor-initiated servicing event. This eliminates the 3-system swivel-chair behavior that drives 6.2 call center contacts per transfer and a 23% client abandonment rate during onboarding."
Add a second heading called Business Case.
Under Business Case, include the revenue impact of reducing onboarding time from 22 days to 8 days (faster AUM capture), and the call center cost reduction from cutting contacts per transfer from 6.2 to 1.5.
Add a third heading called Key Decisions Needed.
Under this heading, list a bullet for each stakeholder group (Legal, Compliance, Technology, Marketing) with the primary decision you need from them.

Why a one-pager instead of a full presentation?

Executive stakeholders rarely read full PRDs. A one-pager forces you to distill your ask into what each group actually needs to decide on, not everything they might want to know.

The full PRD exists as the backup if someone wants detail. The one-pager is what gets the meeting to a decision.

Write the stakeholder-specific sections

Each stakeholder group has different concerns. Your job is to anticipate objections and frame the initiative in terms each group cares about.

Add a heading called Legal.
Write 2-3 bullets addressing: FINRA Rule 11870 compliance requirements for the automated transfer workflow, and data sharing agreements needed with NSCC participants to enable real-time status updates.
Add a heading called Compliance.
Write 2-3 bullets addressing: AML/KYC threshold triggers for large transfers (what dollar amounts require enhanced due diligence), and consent management for bank-linking data under GLBA.
Add a heading called Technology.
Write 3-4 bullets addressing: API integration with ACATS/DTCC for transfer processing, real-time event architecture using Kafka-style event streaming patterns for status updates, and mobile/web parity requirements.
Add a heading called Marketing.
Write 2-3 bullets addressing: client communication strategy for the new unified experience (how do we announce this to existing clients mid-transfer?), and advisor enablement materials needed for the new workflow.

Frame concerns as decisions, not risks

Instead of writing "There is a risk of FINRA non-compliance," frame it as "Legal needs to decide: Do we pursue a phased rollout to maintain 11870 compliance during the transition, or pursue a regulatory pre-clearance approach?" Decisions move projects forward. Risk lists stall them.

What is Kafka-style event architecture?

Kafka is a distributed event streaming platform. When you reference "Kafka-style patterns" in your one-pager, you're describing a system where every transfer status change publishes an event that multiple consumers (advisor dashboard, client notifications, operations queue) can subscribe to independently.

This is what enables real-time status updates without polling. You don't need to specify Kafka by name in a stakeholder doc. The pattern is what matters.

Export and push all artifacts to GitHub

Your final deliverable is a complete GitHub repository that frames all your artifacts as a cohesive portfolio piece.

In Notion, click the ... menu in the top right of your Stakeholder Alignment page.
Select Export, then choose PDF as the format.
Save the file as stakeholder-alignment-one-pager.pdf.
Move the exported PDF into your local wm-servicing-prd repository folder.

Now create a professional README that ties all your artifacts together as a portfolio piece.

Open VS Code and navigate to your wm-servicing-prd repository folder.
Create a new file called README.md in the root of the repository (or update the existing one).
Add the following content to your README:

# Unified ACATS Transfer & Account Funding Workflow

## Overview

Product discovery package for a wealth management servicing initiative: redesigning the fragmented ACATS asset transfer and bank-linking workflow to reduce advisor onboarding cycle time from 22 days to 8 days and cut call center contacts per transfer from 6.2 to 1.5.

## Artifacts

| File | Description |
|------|-------------|
| `as-is-process-flow.png` | Current-state process flow with swimlanes showing the 3-system swivel-chair workflow |
| `to-be-process-flow.png` | Redesigned unified workflow with parallel processing paths |
| `prd-unified-transfer-workflow.pdf` | Full PRD with user stories, acceptance criteria, RACI matrix, and compliance considerations |
| `wireframe-initiate-transfer.png` | Low-fidelity wireframe: unified transfer initiation form |
| `wireframe-transfer-status.png` | Low-fidelity wireframe: real-time transfer status dashboard |
| `wireframe-exception-resolution.png` | Low-fidelity wireframe: NIGO exception resolution queue |
| `wireframes-advisor-dashboard.pdf` | Combined wireframe export for all three screens |
| `stakeholder-alignment-one-pager.pdf` | Executive one-pager addressing Legal, Compliance, Technology, and Marketing |

## Key Metrics

- **Target onboarding cycle reduction**: 22 days → 8 days (64% reduction)
- **Target call center contact reduction**: 6.2 → 1.5 per transfer (76% reduction)
- **Target transfer completion rate**: 77% → 92%

## Tools Used

- **Process Mapping**: Miro (flowchart shapes with swimlanes)
- **PRD & Stakeholder Docs**: Notion
- **Wireframes**: Figma (low-fidelity, grayscale)
- **Version Control**: GitHub

What does this README accomplish?

The README frames your repository as a professional product discovery package. It tells a hiring manager exactly what they're looking at, what problem it solves, and what tools you used.

The artifacts table makes it easy to navigate without cloning the repo. The key metrics section shows you think in terms of measurable outcomes, not just features.

Save README.md.
Push all your files to GitHub by running these commands in your terminal:

cd ~/Desktop/wm-servicing-prd
git add .
git commit -m "Add stakeholder alignment one-pager and professional README"
git push origin main

What do these commands do?

The git add . stages all new and modified files. The commit message describes what changed. The push sends everything to your remote GitHub repository.

Open your wm-servicing-prd repository on github.com.
Verify you can see stakeholder-alignment-one-pager.pdf in the file list and the README renders with the artifacts table below the file list.

Push rejected or README not showing?

If your push is rejected, try running git pull origin main --rebase first, then push again. This happens when your remote has changes not yet in your local copy.

If the README doesn't render, make sure the file is named exactly README.md (case-sensitive) and is in the root of your repository, not inside a subfolder.

help me troubleshoot my GitHub push

Secret mission

Add RICE Prioritization and a Now/Next/Later Roadmap

Your PRD documents what to build, but stakeholders always ask: in what order? Add a data-driven prioritization model using RICE scoring to rank your 8 user stories, then visualize the delivery sequence as a Now/Next/Later roadmap in Miro. This is the artifact that turns a PRD into an actionable plan.

Clean Up Your Resources

This project runs entirely on free-tier tools, so there are no ongoing costs. Decide whether to keep your resources as-is for portfolio use, archive them to reduce clutter, or delete them entirely.

Resources you used:

Notion workspace "WM Servicing Portfolio" with PRD page and Stakeholder Alignment one-pager.
Miro board "ACATS Transfer Workflow - Process Mapping" with AS-IS and TO-BE diagrams.
Figma wireframe file with 3 advisor-facing screens.
GitHub repository wm-servicing-prd with exported artifacts and README.

Keep everything running

No action needed. Choose this if you plan to use these artifacts in interviews or continue refining them.

Your Notion workspace, Miro boards, Figma file, and GitHub repo remain accessible at any time.
Consider sharing your Notion PRD page publicly so you can link to it from LinkedIn.
Keep your GitHub repository public so hiring managers can view your documentation and process artifacts.

Pause - I'll come back to this later

Archive your boards and pages to reduce clutter while keeping everything recoverable.

In Notion, move your PRD and Stakeholder Alignment pages to a Archived section in your sidebar.
In Miro, right-click your board and select Archive to hide it from your dashboard.
In Figma, move your wireframe file to Drafts if it is in a team project.
Your GitHub repository can stay as-is. There is no cost to keeping it.

Delete - I don't want to use this again

Remove all project resources and start fresh. Only choose this if you are certain you do not need these artifacts.

In Notion, open your workspace settings and delete the "WM Servicing Portfolio" workspace.
In Miro, open your board, click the three-dot menu, and select Delete board.
In Figma, right-click your wireframe file and select Delete.
In GitHub, go to your wm-servicing-prd repository, open Settings, scroll to the bottom, and click Delete this repository.

That's a Wrap!

Nice work! You've just built a complete product discovery and requirements package for a wealth management servicing initiative.

This is the exact type of deliverable a VP Product Manager at a wealth management firm would own in their first 30 days. You now have a portfolio-ready artifact that demonstrates you can identify, document, and align stakeholders on a high-impact advisor productivity initiative.

You've learned how to:

Map a complex, multi-system servicing workflow using process flow diagrams with swimlanes in Miro, identifying pain points and quantifying their business impact.
Write a professional PRD in Notion with user stories, acceptance criteria, a RACI matrix, and regulatory constraints grounded in quantitative analysis.
Create low-fidelity wireframes in Figma and a stakeholder alignment one-pager addressing Legal, Compliance, Technology, and Marketing concerns simultaneously.
Added RICE-scored prioritization and a visual Now/Next/Later roadmap showing you think in terms of delivery sequencing, not just feature lists.

Ready to quiz yourself?