A practical guide for engineering leads: what code review is for, why it becomes a bottleneck, and eight practices that keep it fast and useful.
In short
Code review improves quality without slowing the team when changes are small, machines check style and known errors before a human looks, reviewers respond within a business day, and comments focus on design, correctness, tests and security. Treat review as shared learning and risk control, not as a gate that one senior developer guards.
Code review (kodgranskning) is part of almost every professional development process, yet many teams experience it as a queue: pull requests wait for days, comments argue about formatting, and large changes get approved without anyone really reading them. This guide is written by Devies, a Gothenburg-based product and engineering consultancy, for CTOs, engineering managers and tech leads who want reviews that catch real problems and still let the team ship. It covers the purpose, the common failure modes, a step-by-step practice and how review fits with pairing and automation.
What is code review for?
Code review is the practice of having at least one other developer examine a change before it is merged, to find defects, share knowledge and keep the codebase consistent. Its value comes as much from spreading understanding as from catching bugs.
A good review serves four purposes:
- Quality. A second pair of eyes catches logic errors, missing edge cases and designs that will be hard to change.
- Shared knowledge. At least two people understand every part of the code, which reduces the risk when someone is ill or leaves.
- Consistency. The codebase follows agreed patterns, which makes it cheaper to change later.
- Security and compliance. Reviews catch risky handling of data, secrets and permissions, and provide a recorded approval.
Research from DORA supports the lightweight approach. Its guidance on streamlining change approval finds that change approvals are best implemented through peer review during development, supported by automation, and that heavyweight external approval boards have a negative impact on delivery performance, with no evidence that they reduce change failure rates. Peer review recorded in the development platform can also meet segregation-of-duties requirements.
Why does code review slow teams down?
Reviews slow teams down when changes are large, reviewers are slow to respond, and human attention is spent on things a tool could check. Each of these has a straightforward fix.
The typical symptoms are familiar:
- Large pull requests. A change of a thousand lines takes hours to review properly, so it waits, and when it is finally reviewed the feedback is shallow.
- Waiting time. The author starts something else, context is lost, and the change sits in a queue while merge conflicts grow.
- Style debates. Comments about naming, spacing and formatting crowd out comments about design and correctness.
- A single gatekeeper. One senior developer must approve everything and becomes the bottleneck.
- Unclear expectations. Nobody knows whether a comment is a blocker or a suggestion, so every remark becomes a negotiation.
Google's public engineering practices are explicit about speed. Their guide on the speed of code reviews says one business day is the maximum time it should take to respond to a review request, and notes that most complaints about the review process are resolved by making it faster.
Code review best practices, step by step
The most effective review routine combines small changes, automation of the trivial, fast response times and a shared checklist for what humans should look at. Introduce these eight steps one or two at a time.
- Keep changes small. Aim for pull requests that a reviewer can read carefully in under an hour. Split larger work into a sequence of changes that each build and pass tests, using feature flags if the feature is not ready for users.
- Automate the trivial. Let formatters, linters, type checks, unit tests and security scanners run in the pipeline before review. Our comparison of SAST, DAST and SCA explains which security checks belong there.
- Agree a response time. Set a team norm, such as a first response within one working day, and make reviewing a normal part of the day rather than an interruption.
- Describe the change. The author writes what changed, why, how it was tested and where the reviewer should look most carefully.
- Review in priority order. Look at design first, then correctness and edge cases, then tests, then security and data handling, and only then readability.
- Label your comments. Mark each comment as blocking, a question or an optional suggestion, so the author knows what must change before merging.
- Spread the reviewing. Rotate reviewers so knowledge spreads and nobody becomes a bottleneck. Senior developers should also be reviewed.
- Measure the flow. Track time to first review, time to merge and pull request size. Rising numbers are an early sign that review is becoming a queue.
A clear split between what tools check and what people check keeps reviews short:
Check
Done by tools in the pipeline
Done by the reviewer
Formatting and style rules
Done by tools in the pipeline
Yes
Done by the reviewer
No
Known bug patterns and type errors
Done by tools in the pipeline
Yes
Done by the reviewer
Only if tools miss them
Vulnerable dependencies and secrets in code
Done by tools in the pipeline
Yes
Done by the reviewer
Confirm handling of findings
Tests pass
Done by tools in the pipeline
Yes
Done by the reviewer
Are the right things tested?
Design and fit with the architecture
Done by tools in the pipeline
No
Done by the reviewer
Yes
Business logic and edge cases
Done by tools in the pipeline
No
Done by the reviewer
Yes
Data handling, permissions and privacy
Done by tools in the pipeline
Partly
Done by the reviewer
Yes
Readability for the next developer
Done by tools in the pipeline
Partly
Done by the reviewer
Yes
How does code review fit with pairing and continuous delivery?
Review fits best as one feedback loop among several: automated tests and pipelines catch errors in minutes, pairing catches design issues while the code is being written, and review confirms the change before merge. The faster loops reduce the load on the slower one.
Pair or mob programming is a form of continuous review. When two developers wrote a change together, a short final review is often enough. Teams with strong automated testing can also review smaller changes more quickly, because they trust the safety net; our guide to a test automation strategy covers how to build it. Both practices belong to the wider set of habits described in our guide to DevOps for product teams.
Devies has seen how review habits and pipelines reinforce each other at Hedin IT, the technology function of Hedin Mobility Group. As part of modernising the BI platform, the case describes coaching the team on code review, logging and reusable code, and rebuilding the CI/CD pipeline so that every change is tested and deployable in minutes.
Finally, watch the tone. Review comments are about the code, not the person. Ask questions rather than issue verdicts, explain the reason behind a request, and acknowledge good solutions. Teams where people feel safe to submit unfinished work early get better feedback sooner.
Devies
Want a second opinion?
Devies, a Gothenburg-based product and engineering consultancy, works on questions like this with Nordic product and IT teams. Tell us where you are and we will suggest a sensible first step.
Frequently asked questions
How long should a code review take?
A careful review of a small change usually takes between a few minutes and an hour. Google's engineering practices state that one business day is the maximum time to respond to a review request. If reviews regularly take longer, the changes are probably too large or reviewing is not treated as part of the daily work. Splitting changes is usually the quickest fix.
How many reviewers does a pull request need?
One competent reviewer is enough for most changes, especially when automated tests and checks run first. Add a second reviewer for high-risk areas such as authentication, payments or data migrations, or when a specialist view on security or accessibility is needed. Requiring two approvals for everything tends to slow delivery without a matching gain in quality.
Can AI tools replace human code review?
AI review tools can flag likely bugs, suggest improvements and summarise changes, which makes human review faster. They do not understand your business rules, your architecture decisions or the trade-offs behind them as well as your team does, and they can be confidently wrong. Use them as an extra automated check before human review, not as a substitute for it.
What should a code review checklist include?
A practical checklist covers design and fit with the existing architecture, correctness and edge cases, whether tests cover the important behaviour, handling of data, permissions and secrets, error handling and logging, and readability for the next developer. Leave formatting and known bug patterns to automated tools so that human reviewers can focus on the questions only people can answer.







