Selecting the right technology stack: A journey from MVP to production

As Chief Technology Officer (CTO) of Trrue, I'm responsible for selecting the technology stack for the company. This might sound trivial, but it requires careful thought and preparation. Choosing the right technology stack is crucial for the success of any business.

A technology stack is a set of programming languages, tools, and frameworks that work together to build and deploy a software application. In this article, I will share the considerations we made and why we decided to go with Rust and React Native.

Personal Preference and Experience

Choices are always influenced by personal preference and experience. I'm no exception to that. Of course, having a lot of experience in a particular programming language helps to get faster results, but it's not always the best choice overall.

The MVP

For the company, the MVP was developed using Go for the backend and Flutter for the web and mobile clients. The main issue was time, as the MVP had to be completed before a hard deadline. For this reason, Go was chosen for the backend since it's the language I'm most experienced in. For the MVP, this was definitely the right choice since the purpose of an MVP is to show functionality. It doesn't have to be perfect yet.

Going from MVP to Production

As always in software development, new feature requests came in due to adjustments to the business plan and product based on input from potential clients, as well as experiences with the MVP.

Also, we are a FinTech company and must comply with strict regulations. Therefore, software mistakes could theoretically lead to heavy fines if they negatively influence clients or our regulatory obligations. This means that there has to be a very strong emphasis on writing safe code.

Rust

Of course, it's possible to write safe code in any programming language, including Go, but it fully depends on the programmers. And let's face it: Even the most experienced programmers can make mistakes. Many mistakes can be caught through proper testing, but even then, things can slip through the net.

One of the reasons why Rust has gained popularity in recent years is that Rust's system of ownership and borrowing ensures that memory is managed efficiently and securely, but also that many potential mistakes will be caught at compile time instead of runtime. This is exactly what the backend of a FinTech company needs.

Rust is a systems programming language that has been gaining popularity in recent years, and for good reason. Rust is known for its strong memory safety guarantees, high performance, and low-level control, making it an excellent choice for building the backend of a FinTech application. Rust's performance and security features make it ideal for handling financial transactions and data securely.

Additionally, Rust provides low-level control and excellent performance, allowing developers to build high-performance applications that can handle large volumes of data and transactions with ease. Rust's ability to handle concurrency efficiently means that multiple tasks can be executed simultaneously without affecting performance. Go has good concurrency support, but Rust's performance is generally better due to its more advanced memory management.

One argument against using Rust used to be the steeper learning curve and the lack of developers. The latter isn't really valid anymore because the number of Rust developers has grown rapidly in the past few years, especially since more and more companies are implementing this technology. I do agree that Rust requires more effort to learn, but I believe it's worth the investment because it will result in significantly safer code. And, as I said earlier, for us that's crucial.

React Native

Although I initially wanted to use Dart/Flutter for the mobile and web app, I encountered the issue that most of the other technologies we utilize only provide JavaScript libraries. Using official libraries saves a lot of time; therefore, I decided that, at least for now, it will be easier to use React Native.

React Native is a powerful framework that offers numerous benefits for both mobile and web app development. One of the key advantages is its ability to create cross-platform applications. This means that developers can write a single codebase in JavaScript that can be used to build apps for multiple platforms, including iOS, Android, and the web. This can significantly reduce the time and effort required for development, as well as the cost of maintaining separate codebases for each platform.

Another major benefit of React Native is its performance. Despite being a JavaScript-based framework, React Native apps can achieve near-native performance, thanks to its use of native components and APIs. This means that apps built with React Native can offer a smooth and responsive user experience, comparable to that of apps built with native development languages like Swift or Java. Additionally, React Native's hot reloading feature allows developers to see the changes they make to the code in real-time, which can greatly speed up the development process.

When talking about mobile development, there's always the question of whether to do native development or use a framework like React or Flutter. In our case, most of the heavy lifting is done on the backend, and the app is relatively light, so our situation doesn't require the potential performance benefit of native development, and React Native offers more than suitable performance for our needs.

Polkadot and Substrate

Our solution uses blockchain for the tokenization of clients' assets and the reliable collection of ESG metrics. I have tested various blockchain systems, both public and permissioned, but Polkadot really gave us exactly what we needed. Polkadot is slightly different than other blockchain systems.

Originally, Polkadot allowed the creation of parachains, which are blockchains with their own protocol, governance, and token economics. The parachain then uses the Polkadot relay chain for security and scalability. As you can see, Polkadot allows the creation of complete blockchain ecosystems, which makes it significantly different. Nowadays, with the implementation of JAM, things got more flexible, and you no longer have to launch a parachain per se, but you can mix and match the resources you need for your project.

Substrate, Polkadot's development framework, allows us to build a blockchain with a custom protocol suitable for the specific needs of our stakeholders.

There's a lot that I can say about Polkadot and its amazing technology. I will write several articles about it in the future.

Python

We're doing some machine learning as well, so Python is unavoidable. I can't say it any simpler. Our service provides reliable collection of ESG metrics. This prevents greenwashing and provides investors in ESG projects with the data they need to have a higher level of confidence when investing.

Some of these metrics are to be verified manually, but some are automated. The automated verification process can use AI. In 2023, Trrue already conducted a successful experiment about detecting greenwashing with AI, together with Munster Technological University while participating in the UK's Financial Conduct Authority's sandbox.

Just Three Languages?

Although Rust, Python, and TypeScript/React Native will be the backbone of our technology stack, we will also use other technologies where needed or required. And that's not an issue since we'll use a Service Oriented Architecture. This kind of architecture allows us to pick the most appropriate language for each service, which is a very good thing since each programming language has advantages and disadvantages.

Share Your Opinion

Let me know what you think. Have you been in the same position? What did you choose as the technology stack for your project and why?