Throughout my years as a product manager in fintech, I’ve often been asked to “just add a button.”
For example, next to a customer’s bank account information:
“Can we just add a Change button here?”
It sounds like a small change. But in financial products, a seemingly simple feature can quickly turn into a long list of questions.
Let’s use this as an example:
What should we consider when allowing a customer to update their bank account?
First, can we actually change it?
Question 1: Does the customer already have an active investment?
If they do, there are at least two things we need to consider.
First, the current bank account may have already gone through a validation process. For example, we may have verified that the account holder’s name is legitimate and matches the investor’s information.
Second, if we are working with an internal operations system, it may not be the only system that stores the customer’s bank account information. An external fund administrator, for example, may also maintain a record of the investor’s bank account.
So changing the bank account in one system may not simply be a matter of updating fields. We need to make sure the new bank account is legitimate, understand where else that information is stored, and identify which other processes depend on it.
Question 2: Why is the bank account being changed?
The context matters.
Suppose the system is trying to confirm a bank account for an ACH capital call related to an investment subscription. In this case, the bank account may need to be consistent with the information provided in the subscription documents.
But if the system is confirming the bank account for an investment distribution, the rules may be different. The investor may be allowed to use a different bank account to receive the distribution.
The same action — “change bank account” — can therefore mean different things depending on the business context.
Question 3: Is an IRA investment involved?
This is another example of how the underlying business model can change what appears to be the same feature.
For an IRA investment, the bank account may actually belong to the IRA custodian rather than the investor. That means that, in an investor-facing system, the investor should not be allowed to update the bank account directly.
The interface may look similar, but the business rules behind it can be completely different.
Question 4: Are there cases where changing to a specific bank account is not allowed?
There may also be restrictions based on the type of bank account.
For example, in our system, ACH is available only for U.S. bank accounts. If a customer changes their bank account to one outside the U.S., any follow-up ACH transactions will fail.
In this case, allowing the customer to make the change would create a downstream problem.
So we need to ask not only:
“Can the customer change their bank account?”
but also:
“What happens to everything that depends on the bank account after it changes?”

Change Bank Account sits at the center. Each spoke is a domain that can change the rules, the systems touched, or the outcome.
Then, can we change it safely?
Question 5: What security steps should we take?
A bank account is highly sensitive information.
If a hacker gains access to a customer’s account and changes the bank account, a future distribution could potentially be sent to the wrong account. So before allowing a user to make this kind of change, we may need additional identity verification or other security controls.
The “Change” button is easy to build. Making sure that the right person is clicking it is a much harder problem.
Question 6: Does the customer need to sign to confirm the change?
In our case, the offline process already required the customer’s signature, so the automated online process needed to follow the same rule.
But that immediately creates another set of questions:
- What happens if the customer updates their bank information but never signs?
- What if the online signing tool somehow fails but the customer manages to sign it offline?
- Can they start another bank account change request while the previous one is still pending? If so, what happens to the previous request?
Once a signature is required, “change bank account” is no longer a single action. It becomes a process with its own lifecycle. That means we need to think through what happens at every step — especially when we rely on a third-party tool for the signature. What happens when the process fails, is abandoned, or needs to be restarted? These scenarios may not happen often, but they still need to be considered when designing the workflow.
Question 7: What audit trail should we leave?
For changes to sensitive information, depending on the business requirements, we may need to maintain a complete audit trail.
At a minimum, that could include:
- Who made the change
- What was changed
- When it was changed
- What the value was before the change
- What the new value is
This becomes especially important because it is not always the customer who makes the change. Internal Operations teams may also need to update bank account information on behalf of a customer.
Finally, what happens after the change?
Question 8: What does the internal process look like after a bank account change request is submitted?
Up until this point, we have mainly been considering the requirements for creating a bank account change request.
But submitting the request is not necessarily the end of the process.
Normally, the internal operations team may need to be notified, review the request, and take any necessary follow-up actions.
That raises another set of product questions:
- How should the operations team be notified? Do they prefer email or a notification inside the system?
- What actions should operations take after reviewing the request? Should the follow-up process also be built into the system?
- At what point should the customer be notified that the bank account change is effective?
In our case, we decided to keep the follow-up process simple for the time being, since most requests would be approved. For the rare cases where a request is not approved, Ops agreed to handle the process offline and only record the final result in the system.
Question 9: Is any type of reverse action allowed?
Finally, we need to think about what happens when something goes wrong. For example,
- Can a bank account change be canceled, for example, if the customer realizes the wrong account was submitted?
- What if a downstream transaction has already been initiated when the change request is submitted?
These questions may not all become features in the initial release. But they should at least be considered before the feature is designed.

A complete request lifecycle — involving eligibility, security, validation, signature, ops review, multi-system sync
Conclusion: Think Through the Possibilities, Then Prioritize and Communicate
When we think through a feature, we don’t necessarily need to build everything we can think of. The hardest part is often not building the feature. It is understanding everything that the feature touches, prioritizing the work, and communicating the decisions across the company.
Depending on the timeline and team capacity, we may choose the highest-priority requirements for the initial release, implement them, and learn from real-world feedback. There is an important distinction between:
“We haven’t built this yet.”
and
“We haven’t thought about this yet.”
The first can be a conscious product decision. The second can become a production problem.
A “Change Bank Account” button may take a developer a relatively short time to build. But before that button can safely exist, the product team may need to understand investments, transaction types, external systems, security, operations, compliance, signatures, and historical records. The product team also needs to communicate clearly with relevant stakeholders — especially the internal Operations team — about what the new feature does, what it does not do, and what manual steps are still required after it goes live.
The goal is not to automate everything. It is to make sure everyone understands where the system takes over and where humans still need to be involved. That’s why fintech products are often harder than they look: the complexity isn’t always visible in the UI. It’s in everything behind the button.

