Skip to content
Stribog

Compliance

All writing

ISO 27001 Audits: Internal, Certification and Surveillance

Stage 1, stage 2 and every surveillance audit review your clause 9.2 internal audits. How a small team runs them independently and keeps the evidence live.

By 15 min read

Most pages ranking for this question come from certification bodies and compliance vendors, and describe a funnel: gap assessment, stage 1, stage 2, surveillance. The internal audit is a box to tick before stage 2. That is backwards, because the internal audit is the artefact the external auditors keep coming back to.

This article reads the requirements directly: what clause 9.2 asks, how a five-person team can run an internal audit without auditing its own work, what each external audit samples, and how to keep the programme as versioned files every auditor reads. One caveat: ISO standards are paywalled, so clause text below is quoted as reproduced by named secondary sources.

Three Audits, One Thread

The three audit types are governed by different documents and performed by different people:

  • Internal audit. Required by ISO/IEC 27001:2022 clause 9.2 and performed by people you select. You design the programme, its frequency and its methods.
  • Initial certification audit. Performed by an accredited certification body in two stages, under ISO/IEC 17021-1, the standard for bodies that audit and certify management systems.
  • Surveillance and recertification audits. Also performed by the certification body under 17021-1, across the three-year certificate cycle.

The thread between them is explicit in 17021-1:2015, as summarised by the accreditation body IAS. One objective of stage 1 is to "evaluate if the internal audits and management reviews are being planned and performed" (9.3.1.2.2 g). Stage 2 includes "internal auditing and management review" (9.3.1.3 e). Every surveillance audit includes review of "internal audits and management review", first on its list (9.6.2.2 a). Recertification reaches them indirectly: its listed activities include "the review of previous surveillance audit reports", which are themselves partly reviews of your internal audits.

Stage 1, stage 2 and each surveillance audit review the internal audit programme directly; recertification reaches it through the surveillance reports. Neglect the internal audit and every external audit inherits the gap.

The accreditation and recognition questions 17021-1 raises are covered for ISO/IEC 42001 in stage 1, stage 2 and the recognition gap. What follows stays specific to ISO 27001.

Clause 9.2: The Internal Audit You Design Yourself

Clause 9.2.1 sets the purpose. As reproduced by High Table, it reads:

The organisation shall conduct internal audits at planned intervals to provide information on whether the information security management system: a) conforms to 1) the organisation's own requirements for its information security management system; 2) the requirements of this document; b) is effectively implemented and maintained.
ISO/IEC 27001:2022 clause 9.2.1, as reproduced at https://hightable.io/iso-27001-clause-9-2-internal-audit

Clause 9.2.2 sets the mechanics. The organisation shall plan, establish, implement and maintain an audit programme "including the frequency, methods, responsibilities, planning requirements and reporting", and "shall consider the importance of the processes concerned and the results of previous audits". For each audit it must "define the audit criteria and scope", "select auditors and conduct audits that ensure objectivity and the impartiality of the audit process", and "ensure that the results of the audits are reported to relevant management". Then: "Documented information shall be available as evidence of the implementation of the audit programme and the audit results."

Three things are as notable for what the reproduced text leaves out:

  • No fixed frequency. The clause says "planned intervals" and asks you to weight the programme by process importance and previous results. "At least once annually" appears on consultancy pages as if it were the requirement; it is not clause text. Certification bodies have their own expectations, so ask yours and write the answer into the programme.
  • No auditor qualification. The text asks for objectivity and impartiality. It names no certificate, so a lead-auditor course is a way to build skill, not something clause 9.2 demands.
  • No format. "Documented information" can be a file in git or a record in a GRC tool, provided it is dated and shows the programme ran.

The freedom cuts both ways: a programme you designed is one you must defend at stage 1 and at every surveillance.

Independence When the Team Is Five People

The hard part of clause 9.2 for a small platform team is "objectivity and the impartiality of the audit process" when the same five people built, run and change everything in scope. The guidance standard for auditing, ISO 19011, addresses this directly. Its fourth edition, ISO 19011:2026, treats independence as a principle of auditing in clause 4.6:

Auditors should be independent of the activity being audited wherever practicable and should in all cases act in a manner that is free from bias and conflict of interest. Auditors should maintain objectivity throughout the audit process to ensure that the audit findings and conclusions are based only on the audit evidence. When it is not possible for internal auditors to be independent of the activity being audited, every effort should be made to remove bias and encourage objectivity.
ISO 19011:2026, clause 4.6 Independence (iTeh sample: https://cdn.standards.iteh.ai/samples/iso/iso-19011-2026/ce7343b88f46411095b751456a44343d/iso-19011-2026.pdf)

Read the two halves together. The first sentence sets the default, independence wherever practicable, and a floor that never moves: freedom from bias and conflict of interest in all cases. The second accepts that an internal auditor sometimes cannot be independent of the activity, and moves the burden onto the method: if independence is not available, the audit has to show what was done to remove bias instead. The 2026 text does not tie that allowance to organisation size; it applies wherever independence is not possible.

That is guidance, a "should" rather than a certifiable "shall", not an ISO 27001 requirement. Likewise "you can never audit your own work" is an interpretation; the clause asks for objectivity and impartiality. Treat it as a design goal and record how close you came.

A pattern that fits a three-to-ten-person team, offered as engineering judgement rather than as anything the standard prescribes:

  1. Cross-audit by ownership. Map each audit area to the team or person who owns it, and assign an auditor from elsewhere. The data engineer audits access control on the cluster; the platform engineer audits the logging pipeline the security lead built.
  2. Exclude your own changes from your sample. Where full separation is impossible, the auditor must not sample changes, approvals or configurations they authored. Generate the sample list before the audit, from someone other than the auditor.
  3. Record the independence rationale per audit. One or two sentences in the programme: who audits, what they own, why their judgement is not compromised for this scope. This is the documented answer to "objectivity and impartiality".
  4. Rotate. No person audits the same area two cycles running, so the programme does not settle into one reviewer's blind spots.

Two situations justify an outside internal auditor, who can be an individual contractor: a team so small that one person owns nearly every process in scope, and the audit of the ISMS management processes themselves, which the programme's owner is poorly placed to audit. Otherwise, buying an internal audit buys a report, not the habit of auditing continuously that surveillance tests.

Stage 1 and Stage 2: What the Certification Body Samples

Under 17021-1:2015 as IAS summarises it, stage 1 reviews the documented management system and evaluates "the client's preparedness for stage 2", including whether internal audits and management reviews are being planned and performed. Stage 2 evaluates "the implementation, including effectiveness, of the client's management system".

Stage 2 is the broad one. The IAS summary of 9.3.1.3 lists what it includes: information and evidence; performance monitoring, measuring, reporting and reviewing against key performance objectives and targets; performance in meeting applicable statutory, regulatory and contractual requirements; operational control of the client's processes; internal auditing and management review; and management responsibility for the client's policies. Your internal audit programme is one item on that list. The auditor samples it to see whether audits ran as planned, whether findings were recorded against evidence, and whether corrective action closed them, but that is one strand of stage 2, not the whole of it.

For an engineering team, most of the other items land on systems you run. Operational control means the certification auditor asks to see the change process, the access review and the backup restore actually happening, not described. Performance against objectives means the ISMS objectives need a measurement behind them, such as a metric, a dashboard or a recurring report with a history. Statutory, regulatory and contractual requirements means the register of obligations has to connect to a control that meets each one. None of this can be produced the week before the visit if it was not already being recorded.

Before a certification decision, 17021-1 requires "major nonconformities closed" and "minor nonconformities reviewed and have a plan for corrective action" (9.5.2). If the body cannot verify corrections and corrective actions for any major nonconformity "within 6 months after the last day of stage 2", it must conduct another stage 2 before recommending certification (9.5.3.2).

Surveillance and Recertification: The Three-Year Cycle

The initial audit programme in 17021-1 is "two-stage initial audit, surveillance audits in the first and second years following the certification decision, and a recertification audit in the third year prior to expiration of certification". The cycle starts with the certification decision, not with the stage 2 visit. Surveillance audits happen "at least once a calendar year, except in recertification years", and the first must fall no more than 12 months after the certification decision date.

Surveillance audits are "not necessarily full system audits". The IAS summary of 9.6.2.2 lists what each surveillance includes, and your internal audit sits at the top: review of (a) internal audits and management review; (b) actions taken on nonconformities identified during the previous audit; (c) complaints handling; (d) effectiveness of the management system with regard to achieving the certified client's objectives and the intended results; (e) progress of planned activities aimed at continual improvement; (f) continuing operational control; (g) review of any changes; and (h) use of marks and any other reference to certification. Prepare for all eight. Items (d) and (e) mean surveillance wants to see the objectives being measured and the improvement plan moving between visits, not restated. Item (h) reaches beyond the platform to how the certificate is described in sales material. Other surveillance activities may include reviewing "any certified client's statements with respect to its operations (e.g. promotional material, website)", so a trust page that overstates the certificate's scope is in scope too.

Recertification is planned so renewal can happen before the expiry date, includes review of previous surveillance reports, and may need a stage 1 where the management system or applicable legislation has changed significantly. If the certificate lapses, the body "can restore certification within 6 months provided that the outstanding recertification activities are completed, otherwise at least a stage 2 shall be conducted" (9.6.3.2.5).

The cycle rewards a programme whose output accumulates: year-one findings should visibly shape what year two audits, which is what 9.2.2's "results of previous audits" asks for.

The Audit Programme as Documented Information

The evidence the controls produce is covered elsewhere: the tiered audit.k8s.io/v1 policy and hash-manifested evidence snapshots in Annex A you operate, and the API server's audit log backend, configured with flags such as --audit-log-path and --audit-log-maxage, in Kubernetes audit logs into Wazuh. The Kubernetes documentation describes that log as "a security-relevant, chronological set of records documenting the sequence of actions in a cluster". This section is about the clause 9.2.2 record on top: the programme and its results.

Keep the programme as a YAML file in the ISMS repository, changed only by reviewed commits. The layout below is a house convention, not ISO text; the field names map to the clause's own words.

yaml
# Internal audit programme: ISO/IEC 27001:2022 clause 9.2.2 documented information.
# House convention, not ISO text. One entry per planned audit; changes go through review.
programme:
  id: iap-2027
  owner: isms-manager
  approved_in: management-review-2026-12
  methods: [document review, interview, evidence sampling by sha256]
  reporting: Report to management review; findings in audits/<id>/findings.yaml
  basis: >-
    Higher-risk processes and areas with previous nonconformities are
    audited more often (9.2.2: importance of processes, previous results).
audits:
  - id: ia-2027-q1-access
    planned: 2027-Q1
    scope: Identity and access management for the production cluster
    criteria: ["Annex A 5.15", "Annex A 5.18", "Annex A 8.2"]
    auditee: platform
    auditor: auditor-a@example.com
    auditor_team: data
    independence: >-
      Auditor is on the data team, holds no cluster-admin binding and made no
      access-control change in the sampled period.
  - id: ia-2027-q2-change
    planned: 2027-Q2
    scope: Change management for the GitOps policy repository
    criteria: ["Annex A 8.32"]
    auditee: platform
    auditor: auditor-b@example.com
    auditor_team: security
    independence: >-
      Auditor approves no merges to the policy repository; sampled commits
      are drawn from a list generated before the audit by the ISMS manager.
isms/audit-programme.yaml: the clause 9.2.2 programme as a versioned file (house convention).

Each planned audit then leaves a directory, isms/audits/<id>/, holding report.md and a findings.yaml with reported_on, reported_to (the management review that received it) and a list of findings. Every finding, including a conforming sample, cites the evidence it looked at by path and sha256. The check below runs in CI on the ISMS repository and fails when a planned quarter has ended without that record, or when a cited file no longer hashes to what the auditor saw.

bash
#!/usr/bin/env bash
# check-audit-programme.sh: every internal audit whose planned quarter has ended
# must have a report, a dated findings record reported to management, and cited
# evidence whose sha256 still matches the read-only evidence store.
# House convention for ISO/IEC 27001:2022 clause 9.2.2 documented information,
# not ISO text. Needs: bash 4+, mikefarah yq v4, GNU coreutils sha256sum.
set -euo pipefail

PROGRAMME="${1:-isms/audit-programme.yaml}"
AUDITS_DIR="${AUDITS_DIR:-isms/audits}"
EVIDENCE_ROOT="${EVIDENCE_ROOT:?set EVIDENCE_ROOT to the evidence store}"
TODAY="${TODAY:-$(date -u +%F)}"

fail=0
problem() { printf 'FAIL %s: %s\n' "$1" "$2"; fail=1; }

quarter_end() {
  local year="${1%-Q*}" q="${1#*-Q}"
  [[ "$year" =~ ^[0-9]{4}$ ]] || return 1
  case "$q" in
    1) echo "$year-03-31" ;;
    2) echo "$year-06-30" ;;
    3) echo "$year-09-30" ;;
    4) echo "$year-12-31" ;;
    *) return 1 ;;
  esac
}

count=$(yq '.audits | length' "$PROGRAMME")
if [ "$count" -eq 0 ]; then
  echo "FAIL: no audits planned in $PROGRAMME"
  exit 1
fi

due=0
for ((i = 0; i < count; i++)); do
  id=$(yq ".audits[$i].id // \"audit-$i\"" "$PROGRAMME")

  for field in planned scope auditee auditor auditor_team independence; do
    value=$(yq ".audits[$i].$field // \"\"" "$PROGRAMME")
    [ -n "$value" ] || problem "$id" "programme entry has no $field"
  done
  [ "$(yq ".audits[$i].criteria // [] | length" "$PROGRAMME")" -gt 0 ] ||
    problem "$id" "programme entry has no audit criteria"
  auditee=$(yq ".audits[$i].auditee // \"\"" "$PROGRAMME")
  if [ -n "$auditee" ] && [ "$auditee" = "$(yq ".audits[$i].auditor_team // \"\"" "$PROGRAMME")" ]; then
    problem "$id" "auditor's team is the auditee"
  fi

  planned=$(yq ".audits[$i].planned // \"\"" "$PROGRAMME")
  end=$(quarter_end "$planned") || { problem "$id" "bad planned quarter '$planned'"; continue; }
  [[ "$end" < "$TODAY" ]] || continue
  due=$((due + 1))

  dir="$AUDITS_DIR/$id"
  [ -s "$dir/report.md" ] || problem "$id" "no report at $dir/report.md"
  findings="$dir/findings.yaml"
  if [ ! -f "$findings" ]; then
    problem "$id" "no findings record at $findings"
    continue
  fi

  reported_on=$(yq '.reported_on // ""' "$findings")
  if [[ ! "$reported_on" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]] || [[ "$reported_on" > "$TODAY" ]]; then
    problem "$id" "reported_on '$reported_on' is not a past ISO date"
  fi
  [ -n "$(yq '.reported_to // ""' "$findings")" ] ||
    problem "$id" "results not recorded as reported to management"
  [ "$(yq '.findings // [] | length' "$findings")" -gt 0 ] ||
    problem "$id" "findings record lists nothing sampled"
  bare=$(yq '[.findings // [] | .[] | select((.evidence // []) | length == 0)] | length' "$findings")
  [ "$bare" -eq 0 ] || problem "$id" "$bare finding(s) cite no evidence"

  evidence=$(yq '.findings // [] | .[] | .evidence // [] | .[] | [.path, .sha256] | @tsv' "$findings")
  while IFS=$'\t' read -r path want; do
    [ -n "$path" ] || continue
    if [[ "$path" == /* || "$path" == *..* ]]; then
      problem "$id" "evidence path escapes the store: $path"
      continue
    fi
    file="$EVIDENCE_ROOT/$path"
    if [ ! -f "$file" ]; then
      problem "$id" "cited evidence missing: $path"
      continue
    fi
    got=$(sha256sum -- "$file" | cut -d' ' -f1)
    [ "$got" = "$want" ] || problem "$id" "sha256 mismatch: $path"
  done <<< "$evidence"
done

echo "$count audits planned, $due past due, checked against $TODAY"
exit "$fail"
check-audit-programme.sh: fails CI on a missed audit, an unreported result or changed evidence. Needs mikefarah yq v4 and GNU sha256sum.

Run it as EVIDENCE_ROOT=/srv/evidence ./check-audit-programme.sh isms/audit-programme.yaml; set TODAY to replay it as of a past date. It proves something narrow: every due audit left a dated, reported record, each names an auditor from outside the audited team with a stated rationale, and the sampled evidence is unchanged. Whether the audit was any good is the certification body's call, and it now has one place to look.

The internal auditor and the certification body sample the same store and read the same findings record. The CI check ties the two together by re-hashing every file a finding cites.

Where the Audit Register Lives: CISO Assistant or eramba

Plain git is a complete answer for small teams. For a GRC interface, compare self-hostable tools on licence, offline operation, free-edition scope and exit cost:

  • CISO Assistant Community Edition (intuitem). AGPLv3 for files outside the top-level enterprise directory, which is under a commercial licence; one n8n node directory is MIT. Container images under ghcr.io/intuitem/ciso-assistant-community/ are the AGPLv3 builds. It runs with Docker Compose, lists ISO 27001:2022 among its frameworks, and lists audit and campaigns management and evidence management. Version 4.3.4 at time of writing; the project moves fast.
  • eramba Community. Free, with no user or time limit, on your own servers via Docker or a VM image. It includes four of seven use cases: risk, compliance, data privacy and incident management. Its own page lists no audit module for Community and names no software licence, describing itself only as "free and open". It needs outbound access to support-v3.eramba.org, and states that "eramba cannot run fully offline", which matters on an air-gapped ISMS.
  • Git. The programme and findings files above, plus the evidence store. No interface, but nothing to migrate, and the history is the audit trail.

Whichever you pick, keep the evidence store outside it and record paths and hashes in the tool. Replacing a view costs a re-import, not a re-collection of a cycle's evidence.

Failure Modes, Exit Ramps and the Long Game

  • The one-off internal audit. Run once before stage 2, then abandoned. Every surveillance audit reviews internal audits first, so the gap surfaces at the first surveillance. The CI check above turns that into a failed build months earlier.
  • Findings that never change the plan. Year two audits the same areas in the same way. 9.2.2 asks the programme to consider previous results; the git history shows whether it did.
  • Evidence trapped in a tool. Change the tool or the certification body and the cycle's evidence has to be re-assembled. Keep it in a store you run.
  • A stale standard version. IAF MD 26 ended the ISO/IEC 27001:2022 transition on 31 October 2025, and certifications based on 27001:2013 expire or are withdrawn at the end of it. A programme whose criteria still cite 2013 controls is auditing against a standard no certificate is issued for.

The exit ramp is the same in every case: the programme, the findings and the evidence are plain files with hashes, readable without any vendor's software. A new certification body reads the same record the old one did; a new GRC tool imports it. Clause 9.2 and the 17021-1 cycle are designed around a management system that persists across years and auditors, and the record should outlast every tool and every auditor that touches it. For how this compares with SOC 2's opinion-based model, see ISO 27001 vs SOC 2; for which document holds the requirements and which the guidance, see ISO 27002 vs 27001; and for scheduled benchmark scans as another evidence source, see the CIS Kubernetes Benchmark as evidence.

§FAQ/Common questions

Frequently asked

What are the different ISO 27001 audits?

Three kinds. Internal audits are required by ISO/IEC 27001:2022 clause 9.2 and run by people you select, at intervals you plan. The certification body then performs a two-stage initial audit under ISO/IEC 17021-1, followed by surveillance audits in the first and second years and a recertification audit in the third. Stage 1, stage 2 and every surveillance audit review your internal audits and management review.

How do you get ISO 27001 certified?

Operate an information security management system that meets the standard, run internal audits and a management review, then engage an accredited certification body. It performs stage 1 (documentation and readiness, including whether internal audits and management reviews are planned and performed) and stage 2 (implementation and effectiveness). Major nonconformities must be closed and minor ones have a corrective-action plan before the certification decision.

Can a small team run its own ISO 27001 internal audit?

Yes, if auditors are selected to ensure objectivity and impartiality, which is what clause 9.2.2 asks. ISO 19011:2026, the auditing guidance standard, says in clause 4.6 that auditors should be independent of the activity being audited wherever practicable, and that when internal auditors cannot be, every effort should be made to remove bias and encourage objectivity. In practice: auditors audit areas they do not own, never sample their own changes, and record the independence rationale per audit.

How often must ISO 27001 internal audits happen?

Clause 9.2 says 'at planned intervals' and asks the programme to consider the importance of the processes and the results of previous audits. It sets no fixed frequency. Certification bodies have their own expectations, so agree the cadence with yours and write it into the programme.

Does an ISO 27001 internal auditor need a lead auditor certificate?

Clause 9.2, as reproduced, asks for objectivity and impartiality and names no qualification or certificate. A lead-auditor course builds useful skill, and an outside auditor can help where one person owns nearly everything in scope, but neither is a clause 9.2 requirement.

iso 27001 auditshow to get iso 27001 certifiediso 27001 internal audit clause 9.2iso 27001 stage 1 stage 2 auditiso 27001 surveillance auditiso 27001 recertification audit three year cycle

Executive Briefing

Thirty minutes to clarify your infrastructure risk

Walk us through your vendor footprint and regulatory constraints. We will tell you honestly where sovereignty creates leverage — and where it does not. No pitch deck. No obligation.