A guide to assessing the fitness of your mobile app architecture

Imagine you've just launched a new mobile app, but within a few weeks, you start receiving complaints from users about crashes and slow performance. You soon realise that the problem is with your app's architecture - it wasn't built to handle the scale and complexity of the features you added after launch. 

We'll show you how to align your architecture with your app's design and product vision. This will ensure that your app delivers the features that users want and need, while also allowing room for future evolution. 

Next, we'll explore how to embed security and privacy into your app's architecture to protect users' data and prevent hacking attempts. 

Finally, we'll cover how to create a sustainable architecture that can handle the demands of a rapidly growing user base and evolving features.

By the end of this guide, you'll have a checklist of things to consider when assessing your mobile app architecture, and actionable steps to take to improve it. 

Let's get started and ensure your mobile app's architecture is built to last! 

To assess your architecture, there are some key criteria to consider. These are the criteria that we find especially important for mobile architecture, beyond the common principles that apply to any software.

To deliver a high quality mobile app, you need to examine and focus on three areas:  

Functionality: 

• Aligning with design and product 

• Embedding security and privacy 

Efficiency:  

• Creating self-standing development processes  

• Empowering team autonomy through independent app exploration 

 Sustainability: 

• Embracing automation and checklists 

• Establishing governance 

Aligning with design and product

When it comes to building a successful mobile app, alignment with design and product is key. But what does that even mean? Simply put, it means that your mobile app's architecture should support the features and functionality that users want, while also allowing for future growth and evolution. 

Think about it like building a house - if the foundation is shaky, everything else will suffer. The same is true for your app's architecture - if it's not aligned with your design and product vision, your app will struggle to deliver the features and functionality users want, and will be harder to scale and maintain in the long run. 

But how do you know if your app's architecture is aligned with design and product? Let's take a look at two examples: 

Example 1: A mobile app for a streaming service. The architecture of this app should focus on the playback experience and infrastructure. This means addressing questions like: How do we handle offline playback? How do we handle picture-in-picture and interruption handling? How do we optimise video caching and quality adjustments? 

Example 2: A mobile banking app. The architecture of this app should prioritise security and the ability to serve many independent or interconnected services. This means addressing questions like: How do we ensure data access and payment security? How do we handle open banking integration? How do we implement card management features? 

As you can see, these two apps have different needs and therefore require different approaches to architecture. But there are a few key criteria you can use to evaluate how well your app architecture supports design and product. These include: 

• Facilitating the implementation of features that align with the app's purpose 

• Allowing for safe experimentation and prototyping 

• Supporting the safe integration of partially-implemented or disabled features 

By following these criteria, you'll be able to ensure that your app's architecture supports the features and functionality that users want, while also allowing for future growth and evolution.  

And the benefits of aligning design and product with architecture?  

• Reduced lead-time for discovery and refinement 

• Shorter quality assurance lead time 

• Improved overall quality 

• Improved team understanding of app functionality 

• Reduced notice period needed to disable an at-risk feature delivery 

Embedding security and privacy

When examining an organisation’s system architecture, it’s clear how security considerations are implemented, such as services being protected by gateways and firewalls and components for authentication, authorisation, and entitlement management. 

However, these considerations are often missing from mobile apps, even those that handle sensitive information. Individual journeys such as viewing bank balances or applying for a loan may make their own internet connections, which can leave the app vulnerable to the same types of weaknesses that gateways and firewalls are designed to prevent 

That's why we're going to show you how to assess and measure the security and privacy of your app's architecture and infrastructure. By following these criteria, you'll be able to identify potential vulnerabilities and take steps to prevent them before they become a problem. 

• Development infrastructure and architecture should prevent accidental deployment of internal code and assets in production. 

• Development infrastructure and architecture should minimise the risk of, and provide basic safeguards against accidental mistakes and malicious tampering with code. 

• Non-standard or malicious patterns should be easily recognizable. 

The benefits of assessing security and privacy are clear: faster implementation and release cycle time, improved overall quality, reduced operational/security risk. But, let's not forget the most important benefit - peace of mind. Knowing that your app's architecture and infrastructure are secure, meet regulatory compliance, industry standards and protect user's privacy will give you the confidence to focus on building great features and growing your business 

Creating self-standing development processes

Encountering delays in completing a project due to awaiting contributions from others can be frustrating. That's why creating self-standing development processes is so important. 

Think about it like this - imagine your development team is like a well-oiled machine. Each part of the team is working together in harmony, but they're also able to work independently without waiting for the other parts to catch up. This way, the delivery timeline can be significantly shortened, and the teams can work in parallel, with only a brief period at the end to verify correct integration and ensure that there are no mismatches between the teams’ assumptions. 

There may be other external factors that can impact developer productivity if not accounted for. For example, adding a payment card to a mobile wallet can be very time-consuming. The app and the feature should be designed in a way that allows for simulating the addition and removal of a pass as closely to the real process as possible. 

Assessing your self-standing development process is simple. Use the following criteria to evaluate how well your development process minimises dependency on external factors: 

• All functionality should be accessible and testable by developers without live backend services. 

• All functionality should be accessible and testable by developers independently and without significant overhead. 

• Individual features should be accessible and testable independently from each other. 

By following these criteria, you can expect to see faster implementation and release cycle-time, improved incident response, and reduced impact of late or missing dependencies. But, most importantly, you'll be able to build better and faster and give your users the experience they deserve. 

Empowering team autonomy through independent app exploration

Exploratory testing - it's like going on a treasure hunt, but instead of buried gold, you're searching for bugs and edge cases that could impact your app's performance. And just like a treasure hunt, the more tools and resources you have, the more successful you'll be. 

That's why reducing dependencies is key for efficient exploratory testing. When you're able to test the app in an internal build, you can get a quicker and more accurate answer to how a feature works, without waiting for a test account to be set up in a backend environment. And it's not just about testing the app, it's also about providing as much information as possible to the developers if something is found, like a bug or an edge case. 

You should be able to test the app in different situations and environments, like "does this happen in production?". That's why assessing exploratory testing is crucial. Use the following criteria to evaluate how well your process is working: 

• Internal builds should minimise dependency on external factors during exploratory testing. 

• Internal builds should support testing in different environments and conditions. 

• Internal builds should provide enhanced logging/tracing. 

By following these criteria, you can expect to see faster iteration and identification of high-value scenarios by exploratory testers, ease of setup that encourages other team members to test features directly in the app and report any issues, and improved understanding of app functionality by the team. 

But, the most important benefit of effective exploratory testing is making it easy for the team to test and explore the app.  

Embracing automation and checklists

Automation and checklists are your secret weapon in the battle for mobile app sustainability and success. By automating tasks like testing, continuous integration, and reporting, you'll be able to standardise your app's architecture and delivery process and improve its overall quality. 

But it's not as simple as just automating everything. You need a clear strategy in place for which types of tests are necessary and how comprehensive they should be. And remember, a high coverage doesn't necessarily mean high-quality tests. 

To truly get the most out of automation and checklists, aim for the following outcomes: 

• Increased confidence in the app's proper functioning. 

• Reduced time spent on quality assurance. 

• Faster lead times for building features. 

• Fewer bugs in production. 

• Faster response during incidents. 

By achieving these outcomes, you'll also see benefits like reduced cycle time, improved efficiency, and a higher level of quality. 

But, that's not all. To really take your automation and checklists to the next level, consider incorporating visual elements like screenshots and design library components into your automated reports. This will provide a more comprehensive overview of your app's features, and make it more engaging for the team to review. 

Establishing governance

Effective governance may not sound thrilling, but it's essential for the longevity of your mobile app. However, mobile app governance can be a challenging task, as it involves striking a balance between allowing different teams to incorporate the features they need in a timely manner, and ensuring that the app is adequately maintained and its architecture evolves with the needs of the organisation.  

To effectively assess and measure governance and its impact on architecture, it's important to have a development infrastructure that supports the entire lifecycle of a feature and generates automated reports from the state of the code. This includes everything from summary results of automated tests, testing metrics, and reports on the app's functional and non-functional requirements.  

And don't forget about the importance of documentation. High-level documentation of the architecture and its key principles and guidelines can help increase transparency, trust, and alignment within the team. 

The end result? A well-maintained app with a flexible architecture that evolves with the needs of the organisation. Plus, you'll have reduced lead times, lower operational and security risks, and a better understanding of the architecture's intent. Governance may not be the most glamorous aspect of app development, but it's definitely worth the effort. 

Summary

In this guide, we've taken you through the key criteria to consider when evaluating your mobile app's architecture. From aligning with design and product, to embedding security and privacy, to embracing automation and checklists. 

But it's not just about the technical aspects - effective governance is also crucial for the sustainability of your app. By implementing a development infrastructure that covers all aspects of a feature's lifecycle and generating automated reports, you can ensure that your app is well-maintained and its architecture evolves with the needs of the organisation. 

So, whether you're a CTO, engineer, product owner, or anyone else involved in the app creation process, take the time to assess and improve your app's architecture. It may take a bit of effort, but the end result is a top-quality mobile app that meets the needs of your users and your organisation, and will stand the test of time.  

At Zühlke we specialise in developing mobile applications at lightning speed without compromising on quality. With over 50 years of experience in software engineering, we have worked with some of the biggest names including First Direct and HSBC. We also designed and delivered the NHS COVID-19 app in just 12 weeks which was downloaded by 22 million people and was the UK's first certified medical-grade app.