IT infrastructure audit checklist: evidence, findings and a usable roadmap

An IT infrastructure audit is a structured review of architecture, delivery, reliability, security, performance, cost and the people who operate them. Its useful output is not a generic maturity score: it is a set of evidence-backed findings, prioritized by business impact, with an owner, effort estimate and a way to verify the fix.

Use this checklist to prepare an internal review or to understand what a focused external audit should deliver.

What an infrastructure audit is, and is not

An infrastructure audit can cover cloud, on-premises, bare metal, Kubernetes, CI/CD and operational practice. It looks at how those parts work together.

It is not automatically:

  • An independent penetration test.
  • An accredited compliance certification.
  • A guarantee that every vulnerability has been found.
  • A list of product recommendations without evidence.
  • A full application code review or a multi-week resilience transformation.

Formal penetration testing and certification belong to specialized independent providers. Technical evidence can support those activities, but the scope should not be blurred.

When an audit is most useful

Common triggers include:

  • A cloud bill rises faster than traffic or revenue.
  • A new CTO or Head of Engineering needs an outside baseline.
  • A migration, major release or scaling decision is approaching.
  • Repeated incidents have no agreed root cause or owner.
  • A customer or compliance review asks for technical evidence.
  • The team has tools, but no clear account of which ones deliver value.

Define the decision the audit should support. That determines which evidence matters and which areas can remain out of scope.

Prepare scope and safe access

A focused review starts with a short fit call and an access plan. Prefer read-only access where possible. Record which systems are in scope, which checks are allowed and which data must not be copied.

Useful inputs include:

  • Architecture and network diagrams.
  • Cloud accounts, Kubernetes clusters and environment inventory.
  • Repositories and CI/CD configuration.
  • IAM, RBAC and access-review records.
  • Billing and usage reports.
  • Dashboards, alert rules and incident history.
  • Backup, restore and disaster-recovery documentation.
  • Existing policies, previous audits and open remediation work.

Do not treat broad production access as a prerequisite for every check. Configuration review, synthetic canaries and safe log inspection can answer many questions without touching live workloads. Any active test should have an owner, a safe target and a stop condition.

Infrastructure audit checklist

Each item should end with evidence, not just yes or no. Record the source, environment, timestamp and limitation.

1. Architecture and capacity

  • Is there a current inventory of workloads, environments and owners?
  • Are application, database, queue and external dependencies mapped?
  • Are single points of failure understood and intentional?
  • Do CPU, memory, storage and network have measured headroom?
  • Are scaling behavior and scale-up delay tested?
  • Are stateful workload quorum, storage and node-drain behavior addressed?
  • Is the architecture documented accurately enough for a new engineer?

Useful evidence: topology, inventory, telemetry, load-test results, dependency map, recovery design.

2. Tools and platform fit

  • Which tools perform a necessary function, and which duplicate one another?
  • Does each platform fit the actual workload and team skills?
  • Are managed services saving more operational effort than they cost?
  • Are self-managed components properly maintained and monitored?
  • Are versions supported and upgrade paths understood?
  • Is there an exit or migration path for critical platforms?

Useful evidence: tool inventory, versions, license and support records, workload tests, operational effort and cost.

3. Delivery and automation

  • Can one change be traced from review to the running artifact?
  • Are builds, tests and releases repeatable?
  • Is infrastructure managed as code and checked for drift?
  • Are deployments and rollbacks documented and tested?
  • Are routine operational tasks automated with measurable outcomes?
  • Does automation have idempotency and safe failure behavior?

Useful evidence: pipeline runs, artifact identity, IaC plan, deployment and rollback records, automation logs.

For delivery metrics, use the DORA and production DevOps guide to establish consistent definitions.

4. CI/CD and supply-chain security

  • Are pull-request, release and deployment identities separated?
  • Are runners clean and isolated for each trust level?
  • Are caches scoped so untrusted work cannot poison trusted builds?
  • Are deployment credentials short-lived and narrowly scoped?
  • Are third-party actions and dependencies reviewed and pinned appropriately?
  • Do security findings have owners, thresholds and an exception process?

Useful evidence: workflow definitions, runner architecture, IAM/OIDC roles, cache policy, dependency records, harmless denial tests.

The runner security guide provides specific checks and canary-test ideas.

5. Identity, secrets and access

  • Are human and workload identities inventoried?
  • Is access least privilege and reviewed by an owner?
  • Are privileged actions logged?
  • Are secrets stored outside Git and rotated?
  • Are external content and deployment credentials kept apart?
  • Are joiner, mover and leaver processes verified?
  • Are production and non-production boundaries explicit?

Useful evidence: IAM/RBAC exports, secret-manager configuration, access reviews, audit logs, rotation and revocation tests.

For shared Kubernetes secrets, the External Secrets guide covers ownership and refresh behavior.

6. Network and runtime exposure

  • Which services are reachable from the internet and why?
  • Are security groups, firewall rules and network policies reviewed?
  • Is egress restricted where workloads do not need arbitrary access?
  • Are management interfaces private and protected?
  • Are TLS, certificates and renewal monitored?
  • Are Kubernetes service accounts and runtime permissions bounded?

Useful evidence: public-endpoint inventory, route and firewall review, network policy, certificate inventory, safe connection tests.

7. Reliability and observability

  • Do SLOs reflect real user journeys?
  • Do alerts identify actionable conditions and owners?
  • Can responders see the relevant metrics, logs and traces?
  • Are alerts duplicated, noisy or unowned?
  • Are incident runbooks current and linked from alerts?
  • Does telemetry cost match its diagnostic value?

Useful evidence: SLO definitions, alert rules, sample incidents, dashboards, runbooks, telemetry volume and cost.

8. Backup, recovery and change safety

  • Are backups configured for every required data class?
  • Has restoration been tested and validated recently?
  • Are recovery time and data loss measured against targets?
  • Is failover tested, including critical user journeys?
  • Is failback to the normal environment tested?
  • Are migration and rollback paths explicit?

Useful evidence: restore logs, consistency checks, DR exercise records, measured recovery time, failover and failback results.

The disaster recovery guide explains why the return path matters.

9. Performance and release risk

  • Are critical user journeys covered by realistic performance tests?
  • Do tests use production-like data and workload mixes?
  • Are p95, p99, throughput and errors measured?
  • Does profiling identify the bottleneck rather than only the symptom?
  • Are fixes retested under the same conditions?
  • Do performance gates produce actionable evidence?

Useful evidence: workload model, baseline, test reports, profiles, database plans, before/after comparisons.

See the performance engineering guide for test types and tuning workflow.

10. Cost and unit economics

  • Are costs allocated to products, teams and environments where possible?
  • Are idle resources and obsolete storage identified?
  • Are instances and databases right-sized from measured usage?
  • Are data-transfer and observability costs understood?
  • Were commitments purchased before or after right-sizing?
  • Is cost measured per useful unit, not only per month?

Useful evidence: billing export, allocation model, usage telemetry, commitment inventory, cost per transaction or completed build.

The cloud cost and FinOps guide covers the measurement sequence.

11. People, process and ownership

  • Does every critical system have an owner and a deputy?
  • Can routine operations happen without one particular person?
  • Are code, accounts, dashboards and runbooks accessible to the client team?
  • Are incidents followed by owned corrective actions?
  • Are changes reviewed and exceptions recorded?
  • Are skills and training needs based on actual platform demands?

Useful evidence: ownership map, access inventory, runbooks, postmortems, corrective-action tracking and skills review.

Rate findings by impact and evidence

A severity label is useful only when the reasoning is visible. A simple internal scale can be:

Level When to use it Expected response
Critical Active exploitation, exposed privileged access, confirmed data loss or an imminent severe outage Immediate containment and owner assignment
High Credible production, security, data or compliance impact with meaningful likelihood Fix first, with a named owner and a near-term acceptance check
Medium Material inefficiency, reliability gap or missing control that does not present immediate severe exposure Prioritized remediation in the roadmap
Low Limited impact, documentation gap or improvement with small immediate risk Scheduled cleanup or continuous improvement
Observation Useful context where evidence or impact is not yet sufficient Clarify scope or gather specific evidence before deciding

Do not inflate every issue to Critical. The report should explain impact, likelihood and evidence. If something is suspected but not verified, say so.

The report template that makes findings actionable

Every finding should fit this structure:

Field Required content
ID and title Stable identifier and a specific problem statement
Scope Environment, workload, account, cluster or process
Severity Critical, High, Medium, Low or Observation with reasoning
Business impact Effect on users, revenue, delivery, security, data, compliance or cost
Evidence Configuration, log, metric, document or safe test with timestamp and source
Recommendation Concrete change, not "improve security" or "optimize costs"
Owner Person or team accountable for the next action
Effort Estimated engineering effort and dependencies where information allows
Acceptance How the team proves the issue is fixed
Priority and sequence What should happen first and what depends on it

An executive summary should cover the few decisions that matter. Technical appendices can hold full evidence. A roadmap should not hide critical findings behind an average maturity score.

Illustrative findings, not client claims

The following examples show the format only. They are fictional and must not be presented as results from an actual environment.

Example 1: privileged pull-request runner

  • Severity: High.
  • Business impact: untrusted code could access deployment credentials and alter production.
  • Evidence: release workflow checks out the pull-request head and reuses a long-lived cloud key; no actual exploit was run.
  • Recommendation: separate test and release trust levels, use clean execution per job, isolate caches and replace the key with scoped OIDC roles.
  • Owner: Platform Engineering.
  • Effort: depends on the number of workflows and cloud roles.
  • Acceptance: a harmless canary job cannot assume the deployment role or write the trusted cache; the release path still works.

Example 2: untested database restore

  • Severity: High or Observation, depending on data criticality and evidence.
  • Business impact: the stated recovery target may not be met during an outage.
  • Evidence: scheduled backups exist, but no dated restore exercise or application consistency check is available.
  • Recommendation: restore into an isolated environment, validate record and application consistency, measure recovery time and document failback.
  • Owner: Data Platform and SRE.
  • Effort: depends on data size and isolated environment availability.
  • Acceptance: a timed restore and critical user-journey test pass with the expected data state.

Example 3: over-provisioned non-production database

  • Severity: Medium.
  • Business impact: unnecessary monthly cost without a demonstrated reliability benefit.
  • Evidence: four weeks of low utilization and an oversized non-production instance, with no matching peak requirement.
  • Recommendation: schedule or right-size the instance after a representative test and preserve a rollback path.
  • Owner: Infrastructure and the application team.
  • Effort: small if infrastructure as code already exists; larger if dependencies are undocumented.
  • Acceptance: performance remains within the agreed baseline and cost per test environment falls without failed workflows.

A focused five-business-day plan

The five days start when the required access and tools are available, not before.

Day 1: scope and baseline

  • Confirm the decision, scope, access and safe-check boundaries.
  • Collect inventory, architecture, billing and incident history.
  • Resolve access gaps and choose representative workloads.

Day 2: platform and delivery

  • Review architecture, infrastructure as code, CI/CD and deployment identities.
  • Check tools, versions, runners, caches, secrets and network exposure.

Day 3: reliability, performance and cost

  • Review SLOs, alerts, runbooks, recovery, test evidence and telemetry.
  • Compare billing with usage, performance and ownership.
  • Run only the agreed safe validation checks.

Day 4: findings and roadmap

  • Deduplicate findings and verify evidence.
  • Rate impact, choose owners and estimate effort where possible.
  • Separate containment, quick wins and longer architecture work.

Day 5: report and debrief

  • Deliver the written report and prioritized roadmap.
  • Walk through critical and high findings with the responsible teams.
  • Challenge assumptions, record unknowns and agree acceptance checks.

A larger or partially inaccessible environment may need a different timescale. The focused plan should not be used to pretend every system was fully tested.

The debrief is part of the deliverable

A report alone can leave important questions unresolved. The debrief should answer:

  • Which findings need immediate containment?
  • Which recommendations are accepted, rejected or need more evidence?
  • Who owns each accepted action?
  • What dependencies or access are missing?
  • Which fixes need a performance, security or recovery retest?
  • When will the next review happen?

The roadmap should remain usable by the internal team, another provider or the original auditors. Implementation is a separate decision, not a condition for receiving the findings.

Close the loop with acceptance evidence

An audit is not finished when the PDF arrives. Accepted remediation should produce new evidence:

  • Denied canary actions for security boundaries.
  • Passing restore and recovery exercises for resilience.
  • Comparable latency, throughput and error measurements for performance.
  • Actual billing and unit metrics for cost work.
  • Updated ownership, runbooks and access for process changes.

Big Bad Byte's infrastructure audit delivers a focused written report and debrief within five business days of access, with severity, business impact, evidence, next steps and a roadmap the client can use with any implementation team.

Tell us about your setup

Describe what you run and what isn’t working: the cloud bill, response times, releases or recurring incidents. We reply within one business day with a suggested first step, usually a short call or an audit.

Prefer email? Write to info@bigbadbyte.com. Prefer to talk? Schedule a call.