Let's connect
Let's connect

Reference Architecture: A roadmap to efficiency and scalability

Picture of Maciek Gołaszewski, Cloud engineer

Maciek Gołaszewski

Cloud engineer

12 minutes read

As companies expand, the use of varied software solutions across departments can create complexity. However, adopting a unified reference architecture streamlines operations, promoting coherence and alignment with organizational goals. Integrating key elements like interoperability and scalability enables long-term growth and flexibility, fostering innovation and relationship-focused collaboration while staying committed to forward-looking strategies.

What is reference architecture?

Reference architecture is a document set streamlining the process of adding new elements to the existing setup. It ensures a cohesive and interoperable setup within the organization, providing guidelines for technology and services. It acts as a compass, aligning teams with legal, security, and governance standards.

The idea of reference architecture came about to solve issues of using technologies. When teams or individuals without expertise in certain services or domains use technology incorrectly, the company’s focus misaligns in various ways.


Let's assume a company has a great team crafting top-tier applications, mastering all security protocols. However, the team hits a wall when deploying these apps seamlessly or ensuring the apps are client-friendly. They’re experts in some areas but lack the know-how in others.

In that case, a reference architecture helps to resolve these issues. It’s like a how-to guide packed with company-approved strategies for deployment and safe user access. It fills in those knowledge gaps, helping the team implement robust strategies without needing a total skill overhaul or a bigger team.

The reference architecture helps teams use approved practices. It acts as a knowledge repository and a standardized framework. With a reference architecture in place, teams avoid the limitations of their specific expertise.

How to build a reference architecture

If you want to create a complete reference architecture, it’s best to follow several steps.

Here’s the breakdown: 

Step 1: Define the problem

Consider these points to define the problem:

  • Scope Definition: Figure out what the reference architecture will cover and how deep it will go. Pinpoint the specific areas or services it’s going to tackle.
  • Expertise Check: Identify internal resources with the necessary knowledge and skills. Consider if you need to rope in some external know-how.

Step 2: Responsibility model

Determine the who-is-who to create structure:

  • Role Assignment: Define roles and responsibilities for creating, approving, and maintaining this reference architecture. Use frameworks such as RACI to assign roles effectively.
  • Decision Makers: Sort out who’s giving the thumbs up and who’s in the loop for using this architecture within the company systems.

Step 3: Technical guidelines

The same happens with technology. Introduce structure with guidelines: 

  • Existing engineering standards: Outline the architectural patterns, frameworks, and methodologies you will use. Additionally, document where these architectural decisions came from. This enables users to follow them and stay aligned with your approach.
  • Lifecycle Management: Determine the lifecycle of the architecture and its components. Consider how you will manage changes over time, including updates, revisions, and versioning.

Step 4: Create the architecture

Now it’s about time to create the architecture:

  • Documentation Creation: Develop comprehensive documentation for the reference architecture. Provide practical examples, guidelines, and templates that users can easily use and understand.
  • Document more than less: When creating a Reference Architecture (RA), consider that some parts of the reference architecture may be new to the users. Keep in mind that the unknown can be scary, and if users understand the technologies and decisions that led to particular choices, they will be more inclined to use your architecture.
  • Provide automation: For complex architectures, provide tools and code that teams can use to implement their own instances of the architecture.

Step 5: Evaluate and update

Once you’ve written the documentation, you need to keep it up-to-date. Since every company is an evolving entity, improvement is a part of the process:

  • Continuous Assessment: Review and evaluate how users interact with the reference architecture. Use their feedback and usage analysis to identify bottlenecks, pain points, and areas that need improvement or clarification.
  • Technology Landscape Monitoring: Keep an eye on evolving technology. Incorporate the latest security recommendations and design patterns into the architecture. Provide strategies for transitioning from older architectural designs to newer services or technologies.
  • Iterative Refinement: Improve the reference architecture based on user feedback, technological advancements, and changing business needs. Keep refining and enhancing the architecture to make sure it stays useful and effective in reaching organizational goals.

By following these steps and adopting a continuous improvement cycle, you’ll develop a robust and adaptive reference architecture. This supports the organization’s growth and evolving technological landscape.

An example of creating a reference architecture based on our steps

We aim to give you a vivid picture of the reference architecture creation process. And what better way to do that than by diving into a real-life scenario? Specifically, we developed a reference architecture for a client using Kubernetes on Azure. Let’s break it down step by step. We will keep the above-introduced system so that you can follow it easily.

Step 1: Define the problem

The Azure platform is a complex system on its own. Kubernetes introduces another layer of potential complexity. Despite Azure offering the Azure Kubernetes Service (Azure-managed Kubernetes), numerous pitfalls exist. Teams face difficulties delivering and maintaining their products on Azure. 

We aim to create a reference architecture tailored for teams transitioning to Azure. 

We aim to design an architecture that accommodates 80% of the organization. This approach is simpler and easier to implement. Trying to cover 100% of use cases from the start is challenging due to certain edge cases.

 To create this reference architecture, we need the following capabilities: 

  • Deep understanding of the Azure platform 
  • Familiarity with Kubernetes ecosystem 
  • Identification of needed technologies for teams 
  • Determination of security requirements for adopting teams 
  • Access control system for specific resources

Step 2: Responsibility model

We structured the Responsibility Assignment Matrix (RACI) for this reference architecture as follows: 

  • The cloud tooling team
    • Had deep knowledge in Azure and Kubernetes. 
    • Have already created Terraform modules for Azure management. 
    • Was responsible for delivering the reference architecture. 
  • The cloud management team
    • Oversaw the selection of specific teams. 
    • Held a high-level overview of the reference architecture. 
    • Served as the go-to entity for utilizing cloud services within the company. 
  • The networking, security, governance, and financial teams
    • Were consulted in resolving problems from their domain perspective.
    • Informed about restrictions that needed to be followed.
  • The teams using the reference architecture and C-level managers
    • Acted as internal project investors.
    • Evaluated whether reference architecture addressed specific issues.

Step 3: Technical guidelines

The project followed agile methods, using the Kanban framework with Jira. This approach enabled workflow management for different architecture components. 

  • It allowed stakeholders to monitor project progress. 
  • It remained flexible for the delivery team to allocate work. 
  • The architecture decisions were made using the Request for Comment (RFC) approach. 
  • RFCs were shared with the entire organization to gather input and comments.

Semantic Versioning v2.0.0 became the gold standard for the architecture’s lifecycle. It ensures an easy understanding of changes between versions. The main documents and code were on a git server. 

Trunk-based development took the lead, swiftly kicking off in those platform changes. Pull requests handled the changes; at least two teammates had to review them before merging. Code submissions were accompanied by tests covering their functionalities to qualify for merging.

Step 4: Create the architecture

We set up the architecture as one cohesive package. It included a set of Terraform modules that used the Infrastructure as Code (IaaC) approach. These modules were interlinked using Terragrunt, which is a Terraform wrapper. 

Terraform manages aspects of the Kubernetes cluster, such as: 

  • Storage 
  • Secrets and certificates
  • Continuous delivery system

Each resource followed a role-based access system. This system was even simplified by assigning roles to groups instead of individuals. It facilitated seamless adaptations during team transitions. 

Furthermore, we prioritized high availability in our reference architecture design. It aligned with the networking constraints set by the organization.

Thorough documentation, including diagrams and usage examples, meticulously detailed all modules, Terragrunt code, and Kubernetes configurations. The client’s teams can select specific elements from the reference architecture, based on the Terragrunt examples provided. Then they customize their implementations accordingly.

Step 5: Evaluate and update

The initial step involved creating a proof of concept (PoC) to verify that the reference architecture met the initial requirements. After confirmation, we proceeded with the initial release.

The first release was preceded by “show and tell” sessions that demonstrated the architecture’s capabilities and features. The release itself was announced across all possible channels to generate excitement for the project and to kickstart our internal marketing efforts.

After the initial release, we interviewed early adopters. We aimed to address any gaps in documentation, code issues, and other bugs. We also updated the reference architecture to address security threats and changes in Azure services. The updates also covered changes in services provided by Azure and internal ones provided within the company.

We also set up a communication platform that hosted a public channel for user engagement. Within the channel, users could discuss the architecture and its direction. The responsible team and stakeholders were given multiple metrics to monitor the utilization of the reference architecture.

What problems does reference architecture solve?

A reference architecture is a powerful solution for important challenges in organizations. It helps create a smooth and efficient work environment.

Let’s see how this framework solves critical issues.

  • Consistency nurturing individualityReference architecture guides different teams, it’s a middle ground between consistency and allowing for individuality. Each team follows a similar structure that is tailored to their needs. This consistency makes it easier to reason and solve problems across different implementations. It balances uniformity and flexibility, providing a strong foundation and meeting unique team requirements.
  • Interoperability and collaborative synergy – The reference architecture makes sure that different components or systems work together. This makes the whole system more efficient.
  • Optimisation and streamlined efficiencyReference architecture follows regulated architectural principles. This deliberate approach improves resource utilization, enhances performance, and streamlines workflows. This results in solutions that make operations and processes more efficient.
  • Scalability and flexible adaptability – The design philosophy in reference architecture supports scalability. If you need to split or combine products or teams, the standardized architectural approach makes horizontal scaling easier. This seamless scalability lets you expand or consolidate without major overhauls, so you can adapt to changing organizational needs.
  • Standardised communication for unified understandingReference architecture is good at helping organizations communicate clearly and effectively. It provides a common language and framework for communication. This makes sure that everyone understands architectural concepts and practices in the same way. This standardized communication makes processes more efficient and helps the organization have a united vision.

Reference architecture serves as a comprehensive solution. It addresses challenges related to inconsistency, integration difficulties, optimization hurdles, scalability barriers, and organizational communication disparities. Providing a unified and standardized architectural framework enhances collaboration, streamlines operations, and enables efficient scaling and communication across diverse teams and products.

Challenges when creating a reference architecture

Albert Einstein said, ‘Make things as simple as possible, but not simpler.’ This quote is often mentioned when designing reference architectures. Let’s stick to Einstein’s advice as we explore the challenges of creating a complete reference architecture. It tells us to focus on simplicity without sacrificing depth.

Creating reference architectures can be challenging. They need to be simple, comprehensive, agile, and inclusive. This creates a landscape where simplicity works well with effective problem-solving and innovation. The following points aim to empower teams to navigate uprising complexities. They also foster innovation and problem-solving within the organizational framework.

  • Simplicity in Complexity – To simplify complex systems without making them too simple, we can follow Einstein’s principle of simplicity. First, we can start with an overview. Then, we can select key topics that cover most cases. This approach helps us achieve a balance between simplicity and comprehensiveness.
  • Openness and Collaboration – To create a good reference architecture, make it open for contributions from all members of the organization. This way, the organization can use collective knowledge and diverse insights to best use resources.
  • Agile Approach and Feedback Loops – It is important to follow an agile approach when developing reference architecture. This means having frequent feedback loops. The goal is to detect and resolve design issues early to solve issues early in the early stages of the lifecycle. This approach focuses on being proactive rather than reactive.
  • Providing a Core, instead of Limitation – It’s important to recognize that a reference architecture is unable to solve every problem a team might face. Instead, it provides a basic framework without strict limits, allowing flexibility to meet various needs.

Leveraging Cloud Provider Reference Architectures

Cloud providers have their reference architectures. They provide information and best practices for building strong and scalable solutions within their ecosystem. However, adopting these plans quickly may create alignment and flexibility issues for your organization later.

  • Tailoring for Organisational Fit – These reference architectures are designed for the typical cloud provider client. Your organization’s unique needs may require adjustments to align the architecture with your goals.
  • Evaluation of Technology Stack – You should check if the technologies in these reference architectures match your organization’s technology stack and culture. Other open-source options or technologies already in your system or other vendors might be a better fit.
  • Request for Comments (RFC) and ADR – Using documents like RFC or ADR encourages feedback and shows that user input is important in shaping the reference architecture. This approach promotes transparency and inclusivity in decision-making.
  • Compatibility and Integration – Evaluate how well the suggested technologies work with your current infrastructure. This evaluation makes sure that the technology stack in the reference architecture fits with your systems and matches your technological goals.
  • Mitigating Vendor Lock-in – Using a cloud provider’s reference architecture can create dependencies on their technologies or services. This causes problems if you need to switch to another provider or use your resources because of different APIs, required resources, or service limitations.
  • Future Flexibility and Portability – Evaluate the implications of vendor lock-in and strategize ways to mitigate it if needed. Strive for a balanced approach that capitalizes on managed services while keeping an eye on maintaining the flexibility to transition if the need arises.
  • Balancing Managed Services with Cost Efficiency – The cloud provider’s managed services might make operations easier. But you should consider whether using these services or managing them in-house is cheaper. Before doing Proof of Concepts (POCs), consider if replicating managed services is worth the time and money and if those resources and means can be better utilized elsewhere within your organization.
  • Cost-Efficiency in Scaling – Determine which managed services are critical for scalability and efficiency. Striking a balance between leveraging managed services and maintaining control over vital functions ensures cost-effectiveness and optimal resource utilization.

Cloud provider reference architectures provide helpful insights. To successfully implement them, you must customize and evaluate them carefully. Adapt these blueprints to fit your organization’s specific needs and future growth. This will create a strong, flexible infrastructure that aligns perfectly with your goals.


Reference architecture is an indispensable roadmap, guiding organizations toward efficiency, scalability, and innovation. By offering a structured approach through defining problems, establishing responsibility models, setting technical guidelines, creating adaptable architectures, and continuously evaluating and updating, it becomes a robust framework for tackling complex challenges.

This blueprint addresses immediate concerns and future-proof systems, fostering agility and resilience in evolving technological landscapes. Despite its significant benefits, crafting a reference architecture comes with hurdles. Challenges like aligning diverse stakeholder perspectives, mitigating the risk of rigidity, and ensuring ongoing relevance necessitate meticulous attention and collaboration.

Moreover, with the advent of cloud computing, leveraging Cloud Provider Reference Architectures emerges as a strategic move, harnessing leading service providers’ expertise and best practices. 

You have to decide if you should choose a custom approach to reference architecture or a cloud provider’s solution. It always depends on your organization’s needs. No matter the solution, a well-crafted reference architecture is a dynamic tool that empowers organizations to innovate, optimize performance, and adapt to changing environments while staying focused on their strategic goals.

If you liked this article, you also might find these interesting:

What is “Data Mesh”? Redefining Data Platform Architecture →

Curated by

Sebastian Synowiec

Liked the article?

Share it with others!

explore more on

Take the first step to a sustained competitive edge for your business

Let's connect

VirtusLab's work has met the mark several times over, and their latest project is no exception. The team is efficient, hard-working, and trustworthy. Customers can expect a proactive team that drives results.

Stephen Rooke
Stephen RookeDirector of Software Development @ Extreme Reach

VirtusLab's engineers are truly Strapi extensions experts. Their knowledge and expertise in the area of Strapi plugins gave us the opportunity to lift our multi-brand CMS implementation to a different level.

facile logo
Leonardo PoddaEngineering Manager @ Facile.it

VirtusLab has been an incredible partner since the early development of Scala 3, essential to a mature and stable Scala 3 ecosystem.

Martin OderskyHead of Programming Research Group @ EPFL

The VirtusLab team's in-depth knowledge, understanding, and experience of technology have been invaluable to us in developing our product. The team is professional and delivers on time – we greatly appreciated this efficiency when working with them.

Michael GrantDirector of Development @ Cyber Sec Company