Why You Shouldn’t Build Your Own Orchestration Software

Banks don’t like risk. Which is why many think that building critical software in-house is the safer option. After all - if you made it yourself, it must be secure, right?

However, trust us when we say that certain software is far from convenient if you want to build it from scratch. For example, the backbone of any good digital bank, orchestration software.

Orchestration software is as complex as it is essential and in this article we’re going to point out why building your own orchestration software is hardly ever worth it.

6 reasons you shouldn’t build your own orchestration software

Let’s get a few facts out of the way: you can build your own orchestration software if you have very dedicated and talented software engineers. However, in the vast majority of cases, it won’t be worth doing so due to how resource-heavy this process is, as well as how small the margin for error is.

Secondly, while we’ll be talking about building orchestration software from scratch, know that most of these points apply if you use container management software as well. Of course, this type of software does some of the heavy lifting for you. However, container management software is made to have a very general use-case and making it fit the needs of your bank would still make the process not worth the effort.

So, if you were just looking for a yes/no answer, there you have it - it’s not worth it. However, if you’re curious about our reasoning on the topic, here are our main talking points.

1.Creating orchestration software is resource-heavy

Let’s look at our Atfinity software for a second. While we’d say it’s rather advanced and shiny now, implementing the boolean logic behind our RuLa system is something a good software engineer could do on their own.

But it will take them over five years to do so. That might even be a generous estimate, as even I couldn’t remake it in less than two years - and I designed it!

And let’s not forget, it isn’t just time that you’re spending here. Your IT/development team would have to be on this project the entire time and your business would have to shoulder relatively high and consistent costs to see this project through.

Not to mention that any type of setback, like an engineer leaving the team or an oversight leading to a system failure, would push the deadline back significantly and add to the overall spend.

2.Orchestration software is hard to “get right”

Even if your team has the technical expertise to create orchestration software, it’s important to also note how many things are at play here. For example, any good orchestration software should have an automated onboarding process.

However, does your IT team know how to introduce variables into this process so that it can adapt to different circumstances? Or on the other hand, which elements should be coded in as constants to avoid repetitive inputs? And how do you make the entire process fast enough to lower customer frustration?

Then add to that different devices the customer might use, how exactly this information should be logged, where it should be stored, what the front-end should look like, whether it should have accessibility options, etc.

And that’s just one process. So, once you take into account how many automations are typically a part of orchestration software and how demanding orchestration software for the finance sector can be, you’ll see that there are an infinite number of ways to get something wrong.

3.The margin for error is non-existent in banking

While a bad user experience can cost you customers, non-compliance can lead to both incredibly high fines and reputational damage. Therefore, a continuation of the previous point is that regulatory requirements have to be upheld at all times.

In other words, if your KYC/KYB process suddenly stops working due to bad API implementation or your infrastructure doesn’t comply with General Data Protection Regulation, the consequences could be severe. And since many processes that a bank has to perform rely heavily on integrations, there’s more than one bottleneck for such an issue to occur.

The same principle applies if customer data is lost or mismanaged. But more on that in the following section.

4.It’s difficult to keep your orchestration software safe from threat actors

The biggest bank heist in history saw the perpetrator get away with around 1 billion dollars USD. And while that’s a jaw-dropping number, bank robberies might not be your biggest nightmare. After all, the biggest data breach in history was calculated to have caused damages of up to 4 billion dollars USD.

All of this is to say that software security is incredibly complex and also essential. And even if you have a talented in-house IT team, it’s not guaranteed that they could make your orchestration software bulletproof. At least not without constant effort and a lot of resources.

To paint you a picture, let’s look at our software once more. On a basic level, the software was made with security in mind, utilising encryption and intricate firewalls. That much is standard. However, aside from that, we also have to do penetration tests and code reviews on a daily basis.

Not to mention having a dedicated QA team, a team-wide bug reporting system, and multiple partnerships with different security firms to scan and test our code. All of this is essential for keeping Atfinity’s security air-tight. And realistically, many small-to-medium banks would not have the resources to keep up with such demanding processes.

5.It’s hard to make orchestration software adaptable

The initial setup of orchestration software is complicated. However, your job doesn’t end there. Namely, with compliance regulations changing rather frequently, your software has to be malleable enough to keep up.

And this is easier said than done, especially if adaptability isn’t taken into account when laying the foundation for the software. There are also smaller changes that have to be made. For example, if one of the APIs you rely on changes or if certain features become outdated.

And if there are issues in this department, you might have to tear the software apart and build it back up again, which will require a lot of resources.

6.You have very little to gain from making it yourself

Lastly, it’s important to note that even after overcoming the previous five obstacles, you have relatively little to gain. For one, it’s not necessarily going to be all that cheaper as creating and maintaining orchestration software will require a dedicated IT team.

The end result also isn’t going to necessarily be better, as third-party orchestration software is typically going to be made by industry professionals that specialise in that specific type of software.

And even privacy, which we assume is the biggest selling point for creating your own orchestration software, isn’t as impressive as you’d think. For one, like we covered, any type of negligence can lead to a data breach, rendering your privacy moot.

Secondly, you can always host third-party orchestration software on your own servers and get a comparable level of privacy without any of the technical difficulties.

In other words, even if you could build your own orchestration software successfully, you wouldn’t necessarily be ahead of your competitors who just got theirs from a third party developer.

Setting the bar for orchestration software

To round off this article, we’d like to discuss what exactly good orchestrated software looks like. Thus, if you are still determined to create your own orchestration software from scratch, this will be the bar you’d ideally want to surpass.

Of course, we will use our own Atfinity software as the benchmark, since we think it covers all the important aspects of good orchestration software.

• Our onboarding process is fully automated and rule-based. That is to say that customers are only presented with fields that are relevant to their case. There are also preventive measures for human error, with the software not allowing you to move forward before supplying all the needed information in the prescribed manner it should be filled in.
• KYC is handled through integrations with IDV firms such as WorldCheck and IDNow, making it quick and efficient.
• All of the data is centralised and can be used to for Client Lifecycle Management
• The software infrastructure is built upon a no-code approach, meaning that even compliance staff can make changes to the software if needed. This makes Atfinity very adaptable and easy to use, lowering the odds of non-compliance issues.
• Atfinity can be hosted either locally or on our Atfinity Cloud, with the latter boasting impressive security features and an ISO 27001 certification.

For the sake of brevity, we’ll end it there. But hopefully this helps get our point across - orchestration software is very complex and creating it from scratch without sacrificing on quality is a tall order! 

You could build your own orchestration software. But unless your core business is building orchestration software — don’t. Let professionals like Atfinity do the heavy lifting. So you can focus on what really matters: running your bank.