OU blog

Personal Blogs

Christopher Douce

TM470 Considering Software Architecture

Visible to anyone in the world

If you have decided to create a software product, you need to think about your software architecture. In your project report, you need to say something about the architectural design decisions you have made, and find an efficient way to describe the architecture that you have chosen.

Considering Requirements

One useful way to think about architecture is to begin by understanding the requirements of your product - what it needs to do, and who needs to use it. Requirements can be functional (what your software product should do), and non-functional (the qualities it must have).

Although some requirements may guide you towards certain architectural choices (such as, the computing platform you need to work with), there is a more complicated relationship between what you need to do, and your architectural choices. This complexity is neatly explained using the Twin Peaks model, created by Nuseibeh.

A spiral is presented between two peaks; one representing software requirements, the other representing software architecture. There is a movement of the spiral from a low level of detail to a high level of detail.

Figure 1 Twin-peaks model (adapted from Nuseibeh, 2001)

The model shows a series of cycles, where requirements are considered along with architecture.

There is an important connection between the software architecture and software non-functional requirements. If your project emphasises the significance of security and availability, it is likely that you will choose an architecture that enables you to meet those requirements.

When thinking about software architecture, a useful idea is the notion of the architectural style, which you may have been introduced to if you have studied the software engineering module.

Architectural styles

One of the more important (and useful) architectural style, is the client-server style- although it might be sometimes referred to using slightly different terms, such as ‘consumer-provider’ or ‘request-response’.

There are three clients (but there could be many more) sending requests to a single server process, which sends a response to each client.

Figure 2 Client–server architectural style

When thinking about your architecture, you will also begin to think about what bits of software support the client, and what bis of software support the server.

If your software product is to be run through a web browser, you might be looking to use a browser-based interpreted language, such as Javascript (or its more strongly typed equivalent), with a popular framework, such as React or Node.js.

On the server side, to support a web-based application you might also wish to use a server-side language, such as PHP, Python or Java/Typescript, with a server-side framework. The exact choice of your framework will, of course, depend on your problem, and your requirements.

 A diagram with 3 components: a web browser (also called a client), a web server (which is running a web server called Apache, and a language called PHP, on top of the Linux operating system), and a MySQL database.

Figure 3 Component of a LAMP stack

To get you started, figure 3 shows the component of  common architecture bundle which comprises of different bits of software that often work well together - a LAMP stack. which is an abbreviation for Linux (the operating system), Apache (the webserver), MySQL (a popular database), and PHP (the server side programming language). You can readily download the software for a LAMP stack. You can also add additional frameworks to this, such as WordPress or Joomla, if this helps you to solve your problem. You should, of course, always explain why you have made particular architectural choices.

LAMP is one of a number of different technology combinations you might use. There is also WAMP (with W referring to Windows), and a Javascript stack called MEAN, which is an abbreviation for MongoDB, Express.js, Angular, and Node.js.

One important aspect of software architecture is that it helps to manage complexity. A powerful technique that helps you to do this is the idea of software layers; an idea that is presented within figure 4.

A diagram showing the layering of software. There are 5 layers shown, but there could be any number of layers. Each layer provides services to other layers.

Figure 4 Layered architectural style

Some bits of software that you choose will already be structured in layers. To make your software understandable and maintainable (which may be an important non-functional requirement) you might wish to create your own layers.

Layers can be considered to be abstractions. An abstraction is, of course, the essential characteristics of a problem. Creating a software system may involve solving a series of problems, and these can be combined together in layers.

Monoliths and microservices

Another useful way to think about software architecture is in terms of how big the pieces are. To help us think about this, there are two useful terms; the monolith, and the microservice. A software product that has everything in one place can be thought of a monolith. An advantage of a monolith is that it could run quickly, since there isn’t the need to call on external products or services. The disadvantage of a monolith is that it might lack flexibility. To change a monolith (a single bit bit of software) you would have to replace it in its entirety. If you have a non-functional requirement of high levels of availability (you need your software to operate all the time), this may be undesirable.

A microservice architecture is the opposite of a monolith; it is a software architecture that is comprised of different services that are used together, to form a service-oriented architecture. The idea is that different components solve different problems. In a business system, you might get customer information from one service, for example, and use another service to record an order.

 A diagram that shows the element of a microservice. There is a client, a service that provides what the client needs, and a connection between the service and a database. Figure 5 Components of a service

 Figure 5 shows some important elements of a service. The client can be a web browser client, running on a personal computer, or a mobile device. You might also be using a Javascript framework such as React or Node.js to present bit of a user interface. Web requests can be created using a standard format called JSON, which is an abbreviation for JavaScript Object Notation, and sent using something called the Hypertext transfer protocol. This message is then received by a server, which processes it. In the diagram, REST is an abbreviation for Representational State Transfer, a well known architectural style for distributed systems.

The REST API may be a self-contained service that could be running on either your own computer, or another computer that could be located in the cloud. This service would endeavour to respond to the request, potentially extracting data from a database, or adding records to a database.

In your project, you need to consider trade-offs. The advantage of a microservices approach is that it could give you flexibility (which could be a non-functional requirement). The downside of a microservices approach is that a solution can be more complex and might be slower (which might be important if you have a non-functional requirement that emphasises responsiveness).

Considering the cloud

A useful concept that you might come across is the idea of a container. A container can contain bits of software, such as a service. A container can be run on your own computer, or it can be deployed to ‘the cloud’. One or more containers could work together to solve a bigger problem.

During your project you may need to make a practical decision about how and where to deploy your software product. If you are creating a prototype, probably won’t have to worry too much; you might just deploy your software to your laptop. If you wish to show higher level of skills and abilities, you might think about deploying your software to a cloud infrastructure.

There are two really important points to consider:

  1. Cloud software architecture is an entire subject of its own. You need to be aware that a cloud provider will likely use its own terms and concepts, and offer a range of different services. You need to share your understanding of the services that a cloud provider offers, and explain your choices in a clear way to an examiner who may be unfamiliar with the services that a cloud provider offers.
  2. Be aware that cloud providers often charge for the use of their services. Do be aware of any costs that you might potentially incur. The university will not be liable for these costs. When you have finished your project, you should consider taking down any software you may have deployed to the cloud.

When describing any software architecture decisions that you have made, do remember to describe them clearly and thoroughly. You will impress an examiner if you clearly identify and discuss trade-offs.

Patterns

So far, we have looked at software architecture from a high level; bits of software that work together to solve a problem. Before looking at other resources that might be useful, it is worth saying something about design patterns, which relate to software architecture at the code level.

A design pattern is a recognised approach to solve a known problem. If you sense that you might have to do a lot of coding, a recommendation is to look at the Gang of Four Design Patterns book. Sometimes, bits of software that you choose for your architecture will mention concepts that are featured within this important text.

Related resources

The IEEE software engineering podcast, which features interviews with industrial practitioners is a really useful resource. These two blog posts offer some guidance about what might be useful to listen to:

The following TM470 specific blogs may offer some useful guidance about requirements:

You should also look after, and keep track of your software architecture. Anything that you create, whether it is code or configuration files, can be stored safely in a version control system. The following article offers a bit of helpful guidance:

Reflections

Software architecture is a big (and very interesting) subject. There is a lot of detail in this post, and this might seem overwhelming. An important aspect of your project is about managing risk. Whilst it can be interesting to try to learn something new, there is much to be said for drawing on your existing knowledge and skills. If you are a keen Python programmer, and would like to use your project to further refine your Python skills, consider choosing a software architecture which allows you to use (and to show off) your Python skills.

What is really important in your project is that you explain your technical choices in a way that will make sense for the examiner. Draw some diagrams, and the explain your diagrams. If you are a Python programmer, do bear in mind that your examiner’s favourite language might be Java. Do reference widely to educate them about the benefits (and trade-offs) that lie at the heart of your architectural design.

References

Fielding, R. T. (2000) Architectural Styles and the Design of Network-based Software Architectures. University of California, Irvine. Available at: https://ics.uci.edu/~fielding/pubs/dissertation/top.htm (Accessed 15 November 2026)

Gamma, E. et al. (1995) Design patterns : elements of reusable object-oriented software. Addison Wesley.

Nuseibeh, B. (2001) ‘Weaving Together Requirements and Architectures’, Computer, 34(3), pp. 115–119. Available at: https://doi.org/10.1109/2.910904.

The Open University (2025) Block 3 Units 9–12 From architecture to product - TM354 Software engineering. The Open University.

Acknowledgements

Figures 1 through 5 have been drawn from the TM354 Software Engineering module.

Permalink Add your comment
Share post
Christopher Douce

Software Engineering Radio: Software architecture

Visible to anyone in the world

Software architecture is quite a big topic. I would argue that it ranges from software design patterns all the way up the design and configuration of cloud infrastructures, and the development of software development and deployment pipelines.

Software architecture features in a number of useful Software Engineering Radio podcasts. What follows is a brief summary of two of them. I then share an article by a fellow TM354 tutor and practicing software architect who shares his thoughts from 25 years of professional experience.

An important point is that there are, of course, links between requirements, non-functional requirements and architectural design. Architectures help us to ‘get stuff done’. There are, of course, implicit links and connections to other posts in this series, such as to the one that is about Infrastructure as Code (IaC).

On the Role of the Software Architect

In SE Radio 616: Ori Saporta on the Role of the Software Architect Saporta suggests that design doesn’t just happen at the start of the software lifecycle. Since software is always subject to change, this means that a software architect has a role across the entire software development lifecycle. Notably, an architect should be interested in the ‘connections between components, systems and people’. ‘You should go from 30,000ft to ground level’ (13:00), moving between the ‘what’ problem needs to be solved to the ‘how’ problems can be solved.

Soft skills are considered to be really important. Saporta was asked how might engineers go about ‘shoring up’ their soft skills? A notable quote was: “it takes confidence and self-assurance to listen”. Some specific soft skills were mentioned (29:20). As well as listening, there is the need for empathy and the ability to bridge, translate or mediate between technical and non-technical domains. Turning to the idea of quality, which was addressed in an earlier blog, quality can be understood as a characteristic, and a part of a process (which reflects how the term was earlier broken down by the SWEBOK).

A software architect means “being a facilitator for change, and being open for change” in other words, helping people across the bridge. An interesting point was that “you should actively seek change”, to see how the software design could improve. An important point and a reflection is that a good design accommodates change. In software, ‘the wind [of change] will come’ since the world is always moving around it.

Architecture and Organizational Design

The second podcast I would like to highlight is SE Radio 331: Kevin Goldsmith on Architecture and Organizational Design. Goldsmith’s is immediately asked about Conway’s Law (Wikipedia), which was summarised as “[o]rganizations … which design systems … produce designs which are copies of the communication structures of these organizations”. Put more simply, the structure of your software architecture is likely to reflect the structure of your organisation.

If there is an existing organisation where different teams do different things “you tend to think of microservices”; a microservice being a small defined service which is supported by a surrounding infrastructure.

If a new software start-up is created by a small group of engineers, a monolith application may well be created. When an organisation grows and more engineers are recruited, existing teams may split which might lead to decisions about how to break up a monolith. This process of identifying and breaking apart services and relating them to functionality can be thought as a form of refactoring (which is a fancy word for ‘structured software changes to software code’). This leads to interesting decisions: should the organisation use their own services, or should they use public cloud services? The answer of, course, relates back to requirements.

An interesting question ‘was which comes first: the organisational structure or the software structure’ (13:05)? Organisations could embrace Conway’s law, or they could do a ‘reverse Conway manoeuvre’, which means that engineering teams are created to support a chosen software architecture.

A really interesting point is that communication pathways within organisations can play a role; organisations can have their tribes and networks (49:30). It is also important to understand how work moves through an organisation (54:50). This is where, in my understanding, the role of the business analyst and software architect can converge.

Towards the end of Goldsmith’s podcast, there was a fascinating reflection about how Conway’s law relates to our brain (57:00). Apparently, there’s something called the Entorhinal cortex “whose functions include being a widespread network hub for memory, navigation, and the perception of time” (Wikipedia). As well as being used for physical navigation, it can also be used to navigate social structures. In other words, ‘your brain fights you when you try to subvert Conway’s law’.

Reflections

In my eyes, the key point in Saporta’s podcast was the metaphor of the bridge, which can be understood in different ways. There could be a bridge moving from the technical to the non-technical, or could be moving from the detail of code and services to the 30,000ft view of everything.

Goldsmith’s podcast offers a nice contrast. I appreciated the discussion about the difference between monoliths and microservices (which is something that is discussed in the current version of TM354). An important point is that when organisations flex and change, microservices can help to move functionality away from a monolith (or other microservices). A microservice can be deployed in different ways, and realised using different technologies.

I found the discussion about the Entorhinal cortex. Towards the end of my doctoral studies, I created a new generation of software metrics that was inspired by the understanding that software developers need to navigate their way across software code bases. It had never occurred to me that the same neural systems may be helping us to navigate our connections with others.

On a different (and final) note, I would like to highlight the work of an article called Software Architecture Insights by Andrew Leigh. Andrew is a former doctoral student from the OU School of Computing and Communications, a current software engineering tutor, and a practicing software engineer. He shares four findings which are worth having a quick look at, and suggests some further reading.

References

Leigh, A. (2024) Software Architecture Insights, ITNow, 66(3), pp. 60–61. Available at: https://doi.org/10.1093/itnow/bwae102.

Permalink Add your comment
Share post

This blog might contain posts that are only visible to logged-in users, or where only logged-in users can comment. If you have an account on the system, please log in for full access.

Total visits to this blog: 4611441