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