
Security as a Product Journey
Security has always been an important topic in the IT industry, but when I was new to the field, I found it difficult to understand. Unlike product features that directly solve a problem for users, security was often invisible. If the system already had basic protections such as user authentication, I used to wonder: What else do we really need to take care of?
I still remember attending a full week of security training when I first joined the business. We went through countless rules, risks, and things that needed to be considered. Yet I walked away with more questions than answers. How much of it really mattered in practice? How do we know what security measures are needed at a particular point in the product journey? And when a new security requirement comes up, how should we balance it against other product priorities?
At the time, I didn't have good answers to these questions.
After years of working in fintech, I’ve come to see security differently. It isn't a single feature, a checklist, or a project that can simply be marked as “done.” Security evolves with the product. As a product grows, new users, data, workflows, financial activities, and potential risks appear, and each can require another layer of protection.
In the fintech products I’ve worked on, security gradually became a layered product capability, spanning identity and access control, data protection, financial transactions, abuse prevention, and operational monitoring. The interesting part wasn't simply implementing individual security measures. It was learning how to recognize where additional protection was needed, how much was appropriate, and how security should evolve as the product changed.
Looking back, I would summarize that journey through several key aspects.
Start with a Security Mindset
Since security can feel somewhat abstract, especially to people who have never experienced its impact firsthand, it helps to establish a security mindset across the whole team. Rather than jumping into specific solutions, it is helpful to start with a complete security checklist, such as the Small Firm Cybersecurity Checklist provided by FINRA. It provides a broad view of what needs to be considered, beyond just the software itself.
Security is not just the job of the product manager or security team. Developers need to think about it when writing code, while Ops and administrators need to understand how their daily actions can affect the security of the system. The goal is to give everyone a shared understanding of what to look for before diving into specific security measures.
With this mindset in place, a product manager should always ask when building a new feature:
- What security aspects should be considered?
- What is mandatory at this point, and what can wait?
- What could go wrong if we don't implement a certain protection?
Developers can ask similar questions: Does the feature introduce any new security risks, such as exposing sensitive data, creating opportunities for API abuse, or requiring additional validation?
These questions don't mean every feature needs a complicated security mechanism. Rather, they help the team apply the appropriate level of protection and make security part of everyday product thinking.
And this is not a one-time step. Once the team develops this mindset, it comes up again and again as we discuss and design new features. Over time, it becomes part of how the team naturally thinks about product development — and eventually, a cornerstone of the team.
Protect Identity and Control Access
For fintech platforms, where sensitive data and financial actions are involved, basic authentication alone is not enough.
Two-factor authentication (often using SMS to the user's phone) is a good place to start with. More controls can be added around the identity and account security journey over time, for example:
- 2FA can evolve from optional to mandatory for all systems and all users, including customers and admin users.
- Account lockout can be introduced after repeated failed password or verification-code attempts.
- Password-reset links can be given a limited validity period.
- Additional verification methods can also be introduced for higher-risk account actions or recovery scenarios.
What I find interesting here is that authentication did not remain a single login feature. It gradually became a complete journey, including registration, login, recovery, phone-number changes, and exceptional situations.
As the internal operation system grew, permissions and access control of the internal admin system should also be taken care of, following the principle of least privilege — giving people access only to the data and functions they actually needed. Admin permissions can become more granular, access to investment exports should be restricted, and sensitive-data access should be validated at the API level.
So the question evolved from simply “How does the user log in?” to something broader:
“How confident are we that this person is really the account owner, and what should they be allowed to access once they are in?”
Protect Sensitive Data
Once we understand who can access the system and what they are allowed to do, the next question is: What data are we actually protecting — and do we need all of it?
In fintech, products often handle highly sensitive information, including identity details, bank account information, investment records, tax documents, and other financial data. Protecting this information requires more than simply restricting access. Sensitive data should be protected throughout its lifecycle, from collection and storage to access, modification, and removal.
This can involve measures such as:
- Protecting sensitive information at the API level
- Encrypting credentials and other sensitive data before storage
- Adding additional protection when accessing or modifying particularly sensitive documents
- Removing information from a workflow when it is no longer necessary
That last point is easy to overlook, but it is an important product principle: data security starts by asking whether we need the data in the first place.
It is tempting to collect or retain information simply because it might be useful someday. But every piece of sensitive data we collect also creates something that needs to be protected. Sometimes, the best way to protect sensitive data is simply not to collect it.
Protect the Moments When Money Moves
This is where fintech security differs most from ordinary software security. Any user action that can result in money movement deserves extra attention.
For example, when an investor with an active investment changes their bank information, additional user validation and a signed bank-change request should be in place, and the Fund Ops team should be notified so they can review it.
Similar security considerations apply to other financial workflows, including:
- Capital calls
- Distributions and redemptions
- Refunds
- Any other ACH-related workflows
What initially looks like a simple requirement —
“Let the investor change their bank account.”
— turns out to involve many questions:
Who initiated the change?
Should they sign the request?
How do we verify them?
What exactly changed?
Should someone from Ops review it?
When should the new information take effect?
How should we notify the customer or other related parties?
Can we reconstruct what happened later?
This is a good example of how a seemingly simple fintech feature can become complex.
Defend Against Abuse
As a product becomes more mature, another realization becomes important: not every interaction with the system is necessarily legitimate.
A feature can work exactly as intended and still create a security risk when it is used at an unexpected scale or for a purpose it was never designed for. For example, a verification feature may be perfectly legitimate when used by an individual user, but could become a risk if someone repeatedly triggers or automates the process.
This means security controls need to consider not only “Can this feature be used correctly?”, but also “How could this feature be misused?”
Depending on the risk, this might involve measures such as:
- Limiting or validating API requests
- Introducing additional checks for high-risk or unusual activity
- Detecting patterns that may indicate automated or fraudulent behavior
- Reviewing suspicious activity and taking appropriate action
This is a different way of thinking about product requirements. Security is not only about preventing unauthorized access. It is also about understanding how legitimate functionality could be misused, and building appropriate safeguards around it.
Make Security Observable and Actionable

When Prevention Isn’t Enough
Security isn't only something the customer experiences. Internal teams also need the tools to detect, investigate, and respond when something goes wrong. Once we accept that prevention is never perfect, we also need to acknowledge that security incidents aren't always obvious when they happen. Sometimes, the first sign may appear much later.
Therefore, another question becomes important: How do we know when something has gone wrong? And how can we trace it?
Examples of the tools:
- Infrastructure-level controls, such as AWS GuardDuty, for threat detection and monitoring
- Admin login activity logs
- Document-related change logs
- API access controls and logging
This changed the role of the system. It was no longer simply helping Ops and administrators perform their work. It was also helping them monitor important activities and leave an audit trail behind. If something goes wrong months later, we need to know who made the change, when and what they changed, what the previous value was, and whether the action was authorized.
Having a reliable trail means we can investigate what happened rather than relying on assumptions.
Reflection: Security Is Never “Done”
Looking back, there was never a point where we could say, “Security is done.” What changed over time was not simply the number of security controls we had, but the way we thought about security. Instead of treating it as a separate technical concern, we gradually learned to consider security as part of everyday product decisions.
This is also why security felt so abstract to me when I first encountered it. It isn't one feature that can be built and checked off a list. It is the result of many decisions made throughout the product journey: understanding the risks, identifying what needs protection, and deciding what additional safeguards are appropriate.
For a product manager, the goal isn't necessarily to make the product as secure as possible. Every additional security measure comes with a cost — in implementation effort, user experience, operational complexity, or sometimes all three. The real question is where that additional layer of protection is worth the added complexity.
Sometimes the answer is relatively clear. Actions involving sensitive information or financial transactions may justify additional verification, approval, or other safeguards. In other situations, adding another security step may create more friction than the risk warrants. These decisions require product managers to consider the context: the potential impact, the users involved, the business needs, and the effort required to implement and maintain the protection.
Over time, I’ve come to see security less as a destination and more as an ongoing product responsibility. As the product changes, the risks change, and the protection needs to change with it.

