How to Build a Successful Solution Architecture: Case Study

How to Build a Successful Solution Architecture: Case Study

What is solution architecture (in terms of software development)?

Software architecture design is a fundamental procedure for successful application development. It outlines and reasons the structure of the future app. Besides, solution architecture explains how all the application components will function together to achieve the desired result. 

Solution architecture is defined during the project discovery phase as it sets the cornerstones for the upcoming application development. It considers all the functional and nonfunctional requirements to configure the most suitable tech solution for your business. Besides the current state of art, a well designed app architecture should allow some flexibility for future scaling and updates.   

With all said above, it’s necessary to get the application architecture right before moving to the development. Architecture redesign is an extreme measure as it brings fundamental changes to the app which modify the IT infrastructure, possibly tech stack, features performance, etc., and requires high time and cost investment. 

In this article you will find the practices we use at Apiko to successfully design software architecture. Moreover, here’s our website architecture example within the cloud architecture case study. Ready? Let’s begin!

What defines a successful solution architecture?

  • Usability: Achieve maximal accordance between the solution architecture and application functionality that it enables, and future app users’ and stakeholders’ needs and requirements. 
  • Performance: Determine and allocate the right amount of computing resources that is necessary and enough to ensure flawless app performance and smooth user experience.
  • Cost efficiency: Define the level of app quality and performance which will be enough to satisfy your business needs. We clarify this data during the project discovery phase and summarize it in a form of app functional and nonfunctional requirements. Most often it’s possible to achieve a higher level of performance at a higher cost, so there’s a need to find the middle ground.   
  • Reliability: Ensure that the application functions as it’s expected to at all times. 
  • Security: Implement the protection mechanisms to prevent any data leakage and secure the application from possible malware attacks or other destructive activities.  
  • Robustness for future updates and scaling: Both the business processes the application is built for and the technologies it is built with evolve with time. The overall app performance should not be affected by
    • the growing number of users
    • adding new app functionality  
    • features updates
    • updates of any of the technologies the app is built with, etc.

Of course, it’s impossible to foresee all the innovations a solution may face, but it will be easier to implement them when the architecture is robust. 

  • Simplicity: Aim for the simplest solution that will satisfy all of the above-mentioned criteria. Don’t get it wrong: if there are simpler solutions, but they will obviously lead to technical debt, they should be omitted. Just avoid extra architecture complexity when there is no need for it. 

How to reach these criteria?

Follow the best practices. When it comes to developing cloud architecture, we refer to AWS best practices to create a well-architected solution. 

Collaborate tightly with the development team to get a better understanding of the application logic. Analyze the business needs and requirements to come up with the best app architecture.

Pick the proven technologies. New tools emerge nearly on a daily basis, and their functionality often looks very promising. However, many of them get replaced with the newer ones or simply vanish with nearly the same speed. Pay attention to the size of the professional community around a certain technology, and the time since it’s been launched and successfully used. The higher these numbers are, the more certain is the future support of this technology.  

Finding balance between a performant infrastructure and cost efficiency is one of the most challenging parts of solution architecture design. Software architecture for different projects includes different number of variable components and there is no one-fits-all solution.

What types of software architecture are there?

Based on the fundamental structure and resulting application properties, software architecture can be divided into two types: microservices and monolithic architecture.

Monolithic approach consists in building the application as a single functional unit with tight coupling of its components. As a rule, it’s perfect for smaller projects, as it enables their straightforward and transparent functioning without extra complexity. 

While implementing broad solutions may be too much to handle with a single monolithic codebase, microservices provide the required modularity. Loosely coupled components often have their own databases and function as relatively independent units. This means that you can update or modify any of them without having to worry about the overall app performance. 

For even more decoupled microservices and reduced dependencies between them, one can use event-driven architecture. Some popular platforms to implement it are SQS and Kafka.

You can find more details and tips on how to choose one of these architecture types in our article Software Architecture Types: Monolith vs Microservices (the link is included above).

Monolith vs microservices architecture

Depending on the location of computing resources we can define cloud architecture, architecture configured on on-premises servers, and hybrid architecture. While the latter one allows the owner physical access to the hardware, it requires an in-house team of software developers for its support and maintenance. In addition, app scalability depends on the hardware resources available. 

Cloud-based architecture does not allow physical access to the servers. However, it eliminates the above-mentioned challenges by offering monitoring and testing automation, unlimited scalability potential, professional support services and more. No wonder why it’s the commonly used solution with a still growing popularity. 

See the chart showing annual end-user expenses for public cloud services worldwide over a few past years.

Public cloud services market

Source: Statista.com

Hybrid architecture consists in using both on-premises and cloud resources. Most often it’s used to conform to certain policies and regulations, e.g. when some data must be stored on premises only, or to avoid possible latency when processing data from the cloud, etc.

None of these architecture solutions is a universally best choice for every project. It’s necessary to take into account the software peculiarities to select which approach will be the most suitable match.

What types of cloud architecture are there?

Sometimes it is necessary to have your own data center or a number of local servers. However, cloud architecture suits the majority of solutions, so let’s get familiar with its types.

Public cloud architecture is a rather cost-efficient solution when the computing resources belong to and are managed by a cloud service provider, e.g. AWS or Google. Cloud services are delivered using a multi-tenant approach, and provide customers with the capabilities required for their software projects.  

Private cloud architecture is configured on a cloud that belongs to and is managed by the software owner, i.e. is private. For example, it may consist of numerous company's on-premises servers and data centers which do not necessarily have to be located in one place. As a rule, managing a private cloud is more costly than using cloud providers services. However, it allows maximal flexibility, implementing advanced security solutions, and making the most of the cloud resources available.   

Multi-cloud architecture combines the computational resources of multiple public clouds and on-premises servers. Such an approach allows avoiding a dependence on a particular cloud service provider, and a possible cost reduction. It also provides flexibility to pick the services most suitable for implementation of different app features or microservices.

Hybrid architecture is often referred to as hybrid cloud architecture. It’s a subtype of multi-cloud architecture and we’ve described it in the previous paragraph.

How do we design solution architecture at Apiko? [Cloud architecture case study]

Every application is built to match some business requirements. Designing the underlying server architecture is like mimicking the app behavior. It highly depends on the app purpose and functionality, security measures, governmental regulations and restrictions, etc. So, the solution architect tightly collaborates with the development team to find out these details.

What are the stages of cloud architecture development? 

  1. Before we begin building cloud architecture we need to consider
  1. business drivers
  2. functional + nonfunctional requirements 
  3. constraints 
  4. necessity to fit into the existing environment (ecosystem) where the project will be used
  5. flexibility.
  1. Then we choose a suitable type of app architecture: monolith or microservices. After it, we will be able to pick the computing resources. For example, for microservice architecture, we can choose AWS Lambdas or Elastic Container Service with the serverless approach, or pick the appropriate servers for high computing or data processing apps.
  2. Consider what type of cloud services we will use in our application, so that AWS Solution Architect can start configuring appropriate access policies, roles and design networks for the app.
  1. Configure the production-ready environment. Collaborate more with application developers to have a better vision of the application logic and how it should perform. Pay attention to what queries need to be cached, and how.
  1. If there is no cache, the website can be slow and low performant.
  2. If infrastructure caches unnecessary queries or files, it may lead to errors in website usage. 
  1. Implement initial DoS protection, like AWS WAF, to handle suspicious requests. Without such protection the software can crash and be unable to respond to any request. The worst cases may result in personal data leakage. Some common website attacks include
  1. Denial-of-Service (DoS) / Distributed * Denial-of-service (DDoS)
  2. Web Defacement Attack 
  3. SSH Brute Force Attack 
  4. Cross-site scripting (XSS)
  5. Directory Traversal
  6. MITM Attack
  7. HTTP Response Splitting Attack
    1. Test the production-ready environment with load-testing tools, e.g. Gatling, to see how performant the infrastructure is in terms of scalability and efficiency. Load testing can also show us how the application performs during POST or GET requests, and what queries are slowing down the application. After that, we can decide what should be fixed, or configured for the production environment. 
    2. After the architecture is designed, it is used by the development team to see the key components of the underlying infrastructure.

    What does Apiko website architecture look like?

    You can see the Apiko website architecture diagram below.

    Website architecture diagram

    We have picked S3 as a static hosting for our website which saved us from configuring additional servers.

    ECS is a container service managed by AWS which provides all the computing power. It’s a cost-effective solution, as it’s easy to scale it up or down whenever needed.

    We’ve picked S3 Bucket as an object oriented storage for private or public files. 

    CloudFront has been chosen for caching.

    Is a new solution architecture necessary for every project?

    You don’t need to build new solution architecture for relatively minor projects designed to work within an environment similar to an already existing one. Those can be  

    • small modules 
    • landing pages 
    • content updates and minor changes to an existing application, etc.

    Let’s sum it up!

    It’s a must to design software architecture correctly before the very beginning of your project development. Poor architecture design always affects performance and overall user experience. For example, it can be caused by wrong server CPU or RAM configuration, or caching of the wrong queries, etc.

    At Apiko, AWS-certified solution architects collaborate tightly with the development team to set the basis for well-reasoned decision making regarding the solution architecture. Even the perfect underlying infrastructure can’t really perform at its best if the application is not optimized, or is poorly designed (doesn’t use caching, has unoptimized database queries. etc.), and vice versa. Active communication with the software engineers helps us reach a much-needed balance between designing the perfect application architecture and its underlying infrastructure configuration.

    We use the best practices and proven technologies to minimize any risks and future-proof software solutions. Do not hesitate to reach out if you need any assistance, have questions, or would like to discuss your ideas with us!

Loading Comments
CareerServicesIndustriesPortfolioCompanyBlogContact Us
(ノ◕ヮ◕)ノ*:・゚✧1
Apiko

Get in touch

letter img
location icon
Lasnamae linnaosa, Pae tn 25-47,
Harju maakond, Tallinn,Estonia, 11414
CareersContactsBrand kitGDPR Compliance
IndustriesManufacturingTransportation & logisticsFacility managementFintechHuman capitalB2B solutionsE-learningE-commerce & retailBooking & reservationJob board marketplaceFood marketplace

© 2014 - 2023 Apiko. All rights reserved

clutchgithubfacebooklinkedintwitterdribbble icondribbble