Much like many other business sectors, the banking industry has had to accelerate their digital transformation efforts as a result of the COVID-19 pandemic.
Today’s retail banking industry is a far cry from where it was even just five years ago. Consumers no longer have to physically appear in their bank to process payments or open new accounts. Mobile and web apps feature intuitive experiences and sophisticated functionality. Overall, retail banks and their software development teams have done a tremendous job in creating tools that are integral parts of personal banking today.
However, while significant gains have been made in retail banking over the last few years, the commercial banking sector is lagging behind. For all of the innovation within the retail banking experience space, the commercial banking space is still as fragmented and “untechnical” as ever. For developers, this means they have their work cut out for them.
If you’re a developer who wants to delve into the banking space or if you’re just beginning to work on commercial banking products, here are a few things to keep in mind.
Be Prepared to Work with Outdated Tech
One of the biggest challenges developers will face is that, more often than not, commercial banks are relying on decades-old legacy infrastructure.
As banks have evolved, their IT teams, vendors and consultants have routinely built layers on top of and beside core banking systems. The problem is in many cases, these layers were designed and implemented when authentication delegation, microservices and event-driven architecture were either too novel or nonexistent.
Therefore, developers need to resign themselves to meeting the banks where they are in terms of technology. For example, they might see files instead of APIs, obscure XML schemas (never mind JSON), unexpected throttling and batching in addition to an overall lack of more advanced tools such as webhooks, events, streams and reporting.
Patience is Key
While elsewhere in the IT industry speed is king, many large organizations such as commercial banks tend to operate at a much slower pace. This goes beyond just using a “slower” methodology or having a “slower” development process with lengthier iterations. Unlike in a startup, the development process within larger organizations is a part of a bigger business process — and business processes in banks take a lot more time and effort and are subject to much greater scrutiny. Developers should expect a slower pace and must understand the need to be patient.
Embrace the Unknown and Experiment (Responsibly)
Banking, finance and accounting are very complex, intricate domains. Moreover, banks are large and complex organizations whose inner workings most developers are not generally familiar with. Therefore, developers may be afraid of making mistakes and opt for safety over creativity. This simply can’t be allowed to happen. Of course, no one likes to make mistakes. However, mistakes are often a key building block in innovation. Instead of letting the unknown stunt innovation, developers should embrace this unfamiliar terrain as an opportunity to experiment. Granted, there need to be quality control steps in place to make sure that these experiments don’t cause havoc or send critical functionality off the rails.
Here are a few best practices that each role can follow to strike the right balance between experimentation and objective achievement:
- Engineering managers:
- Build a culture that encourages writing clean code followed by refactoring.
- Ensure developers understand the business and prioritize addressing customers’ pain points.
- Make sure the organization allocates sufficient capacity to accommodate the cost of innovation.
- Don’t rush putting things into the core of your platform.
- Move side effects to the edges of your application and decouple them from the business logic. Moreover, strive for keeping business logic as pure as possible when it comes to functionality; for example, make sure the same inputs produce the same outputs without creating side effects or depending on them.
- Use the Theory of Jobs-to-be-Done to better understand the customers’ needs. It takes much longer to understand how the banking industry works than to understand the customers’ jobs-to-be-done and their needs.
Having these guideposts in place will help developers become more comfortable with sparking innovation in commercial banking and allowing creativity to flourish. Understanding and accepting these challenges will enable developers to build the sophisticated tools and experiences that have been long overdue in the commercial banking space.