# Engineering best practices

## What it is

Engineering best practices are ways of working with enough evidence behind them to serve as
the normal choice in a stated situation. Regularly restoring a backup in a separate
environment is a good practice when a team needs to know whether it can recover. A written
recovery plan, a successful backup job and a measured restore answer different questions. The
practice earns its place because the restore shows what data can actually be opened, how long
it takes and where someone still has to improvise.

A practice can be recommended by a research group, an engineering organization, a project or a
standards body. The recommendation usually assumes certain conditions, such as a team able to
deploy independently or someone able to review a change. A team can adopt it as advice, make
it an explicit rule or show how it meets a contractual obligation. Those are distinct
commitments. An outside recommendation becomes mandatory for a team only when an applicable
obligation or the team's own agreed rule makes it so.

NIST's Secure Software Development Framework, version 1.1, organizes secure development
practices around high-level outcomes that can be added to a software development lifecycle. It
presents tasks and examples of ways to implement them. This distinction is useful outside
security too. Producing reliable evidence that source changes were reviewed is an outcome.
Requiring a particular button in a particular hosting service is one possible implementation.
Where the outcome is explicit, another team can decide whether its review process supplies
equivalent evidence and preserves the required protections.

The title “best practice” is also used formally. The IETF publishes a Best Current Practice
series, with a process described in RFC 2026. RFC 8174 clarifies when the capitalized words
described by its companion RFC carry special meaning in a specification. In another context, a
team may use “best practice” to mean established advice. Read who issued it, where it applies
and what it asks before treating the phrase itself as authority.

## Why it matters

A sound default saves people from settling the same question on every change. A new developer
sees the expected evidence before opening a review. Operators get comparable information from
one release to another, and teams sharing a service can agree on which actions warrant
notification. The saved time depends on the practice being clear enough to apply. “Review
carefully” leaves people to invent different criteria. Asking someone to demonstrate that a
customer cannot be charged more than once gives the review something observable to agree on.

Defaults also make exceptions visible. Consider a team that ordinarily releases small changes
frequently. A device firmware update may require a field technician to isolate a machine,
apply the update and verify the device at the site. The small-change principle can still
influence the design, test sets and rollout order. The frequency of the physical release
changes because the conditions of recovery are different. Stating the reason helps people keep
the part that still reduces risk.

Evidence is also local. DORA describes trunk-based development in terms of integrating small
changes frequently and identifies capabilities and measures teams can use to examine delivery.
That is a practical lead for a team with long-lived branches, slow integration and recurrent
merge work. The team still needs to observe its own integration time, rejected changes and
recovery behavior. A smaller branch count alone may simply show that the team stopped counting
some branches, or began combining more work behind each merge.

## What it looks like in practice

Imagine a team that maintains an internal reporting tool. Pull requests must have a second
reviewer and the shared test suite must pass. This rule usually catches omissions while
changes are cheap to correct. When a monthly report is late, the usual test suite spends
several hours replaying fixtures that cover an unrelated export path. The proposed fix changes
only the report's filter and is reversible before the report is distributed.

The team first checks its actual obligations. If approval before release is required, a faster
route still needs authorized approval. It then names the relevant risk. The urgent fix must
include the correct records, keep the previously agreed grouping and avoid exposing rows from
other business units. The author runs focused tests with known input and compares the
generated report against expected rows. A separate reviewer inspects the diff and checks those
results. Someone is named to decide whether this evidence is sufficient, and the previous
report is kept ready in case the comparison fails. The full test suite runs afterward and will
inform whether the team wants a faster permanent check.

The short exception record states the normal rule, why the case qualifies, which protections
still apply and when the exception expires. It records the actual elapsed time and outcome. If
the team needs the same exception again the following month, it can move the report-specific
assurance into its regular workflow. Before changing the default it checks that the faster
route can detect a wrong date filter and a deliberately excluded business unit. A check that
fails on those seeded errors supplies stronger evidence than a timer alone.

Engineer’s case on
[a commit gate of 22 linters with no warning tier](/portfolio/built-a-22-linter-commit-gate/)
describes making a project's agreed checks enforceable at commit time. A different
[accessibility case](/portfolio/the-accessibility-faults-your-checker-misses/) describes
defects encountered despite automatic checks. The two examples expose different questions. A
gate can enforce a rule consistently while the underlying test still covers only part of what
users experience.

## Where it goes wrong

**A checklist becomes the goal.** A process marked complete can still produce the failure it
was supposed to prevent. Choose one sample where the practice should clearly make a difference
and observe it. Check that the reviewer can reconstruct the change, that the restore opens
usable data or that the release actually reaches the intended users.

**A tool is mistaken for the practice.** Buying a review platform does little if nobody has
enough time or context to disagree with a change. Write down the outcome that the tool is
supposed to support. Then inspect a real example with the people who use it and find out
whether the promised information is available in time.

**A local exception becomes a quiet default.** A workable emergency path tends to get reused.
Give exceptions a stated scope, an accountable person, a compensating measure and a review
point. Repetition is useful evidence that the normal route deserves attention. Improve it
openly when that evidence holds.

**A team's evidence is copied without its context.** A rule can work under different
deployment, staffing or product constraints. Start with the problem described by the source
and compare it with yours. Try a bounded change, decide in advance what improvement and harm
would look like, then keep the practice when the observations support it.

## Further reading

- [NIST Secure Software Development Framework, version 1.1](https://csrc.nist.gov/pubs/sp/800/218/final)
  — the framework's practices, tasks and examples of implementation.
- [RFC 2026, section 5](https://www.rfc-editor.org/rfc/rfc2026.html#section-5) — what Best
  Current Practice means within the IETF's standards process.
- [RFC 8174](https://www.rfc-editor.org/rfc/rfc8174.html) — when capitalized requirement words
  have their defined meaning in an IETF document.
- [DORA on trunk-based development](https://dora.dev/capabilities/trunk-based-development/) —
  small changes, frequent integration and ways to assess the practice.

<https://engineer.company/glossary/engineering-best-practices/>
