Building a personal banking iOS app
banking infrastructure finance fintech

Building a personal banking iOS app

Kyle Redelinghuys
Kyle Redelinghuys

As part of of my project to build out banking infrastructure I needed to create something “above the line” to showcase the functionality. Since the functionality has been implemented and stabilised, I have been deciding on the best way to show what can be done with this, outside of command line client commands to a server.

The options for showcasing this functionality came down to two initial choices: a web application, or a mobile application. Since mobile is the first choice for most types of interaction with applications, I decided to go this route even though web would have been far easier due to my background as a full stack web developer.

The project needs a name

In order to refer to this project as something other than “banking infrastructure for today’s world” I decided to come up with a name. I landed on The Bank Of Today due to its simplicity and accurate representation of what this project is about: building banking infrastructure using today’s technology. The logo is a bull which is associated with the financial world.

An introduction to iOS

Up until last week, I had never touched iOS development. In order to be as productive as I could from the start I went through a great course on Udemy which gave me what I needed to know to get the ball rolling. Using Swift has been a pleasant experience and seems fairly easy to pick up. There’s a lot of magic that comes with XCode which aids development and coming from a completely non-IDE world (Vim will always come out tops for me) there are some situations where an IDE is needed.

Building the app

I decided to choose simplicity in development to get as far down the road as I could, as quickly as I could, while still maintaining good standards. As a result, I opted to use straight TCP connections (even though the banking backend now supports TLS). As soon as the iOS app was successfully making calls to the server I moved on to building the functionality out.

1) User accounts - Create

When the app is first installed, a user should be able to create an account on the banking backend. This would be equivalent to opening a bank account, and sending through all necessary information to do so. Processes in the backend will help to ensure that no fraudulent or otherwise improper accounts are created, for now it lets any account be opened.

On account creation, any errors are displayed to the user if the call failed (e.g. the ID number failed to validate). If the creation is a success, the user’s UUID is saved into Swift’s NSUserDefaults.standardUserDefaults(). The user is then taken to another screen where they enter in a password for their account.

A user has a bank account, as well as an application account linked to the bank account. This application account has a password associated to it, and the user name is the client’s bank number (a UUID V4 value). The user never has to know his username as it is stored in the application itself in the background.

If the password validates and the call is successful, the password is saved in plain text in NSUserDefaults.standardUserDefaults() (this will be encrypted in future). All the authentication information needed by the application is now present.

2) User accounts - Login

Once the above process has been completed, the user will be able to log in. This log in is done automatically after account creation, and any further attempts to use the application after that would require the password to be inputted by the user. This password is then compared to the password stored in NSUserDefaults.standardUserDefaults() and if successful the user is logged in.

3) Authenticating requests

The authentication of requests occurs in a few ways. The optimal way uses a token so as not to send through the password and userid everytime a call is done. If a token is present, it is sent to the server to auth any request. If this call fails from an invalid token, the application tries using the username and password, and receives a token. This token is then used for subsequent calls. This token has a TTL (defined in the server, default is one hour), and can be refreshed.

All of the above calls can be referenced in the previous post on building out the authentication and calls.

Building the user interface

I put as much time into the user interface and UX flow as necessary (read: not that much). The interface looks pretty good and does the job, undoubtedly there is a boatload of improvement that can be done. The to-do list for improvements includes better flow between screens, better UX around both parts of account creation vs logging in, and small bugs around displaying and interacting with information.

With all that said, below are the current screenshots of V0.1 of The Bank Of Today iOS application.

Landing screen
Account create
Account password
Login
Account summary

Conclusion

The iOS application now allows users to create accounts, create passwords and log into their accounts. The next steps are to: pull the user’s account balance, retrieve a list of other user’s accounts to make payments to, make payments to said users, and use push notifications to update on transactions. I am also planning to have deposit functionality introduced into the banking server, allowing for a mock ecosystem for transactional accounts.

As always, the code is open source. The iOS app is available on Github, and the banking infrastructure code is available here.