What professional software engineering looks like to a client
Architecture, code review, automated tests, small releases, monitoring and code you own: what a professional engineering team does, and how to recognise one.
Most clients never see the code they pay for, and they should not have to read it. Yet the way it is written decides how much the software will cost to change next year, how often it breaks, and whether anyone but its author can look after it.
You can judge all of that without reading a line. Professional engineering leaves traces a client can see, ask about and check. Here is what they look like from your side of the table.
Why the way it is built matters to you
Software is never finished. The day it launches, the list of changes begins: a new payment method, a new branch, a new report, a rule the regulator added. Well-engineered software takes those changes in its stride. Poorly engineered software gets slower and more expensive to change each time, until a rewrite looks cheaper than the next feature.
The difference rarely shows in the first demonstration. On launch day both look the same. It shows in the second year, which is why it is worth asking about in the first week.
Architecture before code
Before anyone writes code, someone should decide how the system is put together: where the data lives, how the parts talk to each other, how people sign in, and what happens when traffic grows or a supplier's service goes down. That is architecture, and it is cheapest to get right on paper.

From your side, it should arrive as a short written design you can read and question. It names the main parts, the technology, the hosting and the risks, and says why each choice was made. If a team cannot explain its plan in plain language, it may not have one.
Every change is reviewed and tested
On a professional team, no change reaches your users because one developer thinks it is fine. Each change is read by a second developer before it is accepted. Review catches mistakes early, and it spreads knowledge, so more than one person understands every part of your system.
Automated tests do the rest. They are small programs that check the software does what it should: that a discount is applied correctly, that a customer cannot see another customer's orders, that last month's bug has not come back. They run on every change, and they are what makes it safe to touch old code. Ask what the tests cover, and what happens when one fails.
Small releases, watched closely
Professional teams release often and in small pieces. Each change passes through the same automated steps: built, tested, deployed to a staging copy you can try, then to the live system. This is continuous delivery, and it turns a release into a routine afternoon rather than a tense weekend.

Small releases are also easy to undo. When something goes wrong, the team knows which change caused it and can roll it back.
Once the software is live, it is monitored. Errors, slow pages and failed payments raise alerts that reach a person, so problems are usually found by the team before customers notice them. Ask who receives those alerts, and at what hours.
Documentation and code you own
Software that only its author understands is a risk to your business. A professional team writes down how the system is run, deployed and configured, and why the important decisions were made, and keeps those notes next to the code, where they stay current. When that is missing, the next team starts with guesswork, as anyone who has moved a legacy system to the cloud will know.
The code itself should be yours, kept in a repository under your organisation's account or handed over in full, with the hosting, domains and store accounts in your company's name. If you changed teams tomorrow, the new one should be able to start from what you hold.
How to tell a team from a freelancer
Many freelancers write excellent code, and for a small, self-contained job one can be the right choice. The difference with a team is not talent. It is what happens around the code, and what happens when someone is ill, busy or gone. Ask any provider:
- Who reviews the code before it goes live?
- Which tests run on every change, and can we see them?
- How do you release, and how do you undo a release?
- Who is alerted when the system fails at night or at the weekend?
- Where is the code kept, and in whose name are the accounts?
- If the person who built this leaves, who knows it next?
A team should answer each one quickly and show you the evidence. Vague answers are an answer in themselves.
How Angry Monkey Agency can help
Angry Monkey Agency is an engineering team with nearly ten years of building and running software: architecture first, review and tests on every change, small releases, monitoring, and code that belongs to the client. You can read more about how we engineer software.
Read how we work in software development, look at the work or start a project.