Talk to a specialist
Home / Resources / ISO 27001 guide / ISO 27001 secure development, testing and change management

ISO 27001 · Practical business guide

ISO 27001 secure development, testing and change management

Build security into design, development, testing and release. Make changes accountable through clear requirements, proportionate checks and evidence of the deployed result.

In this guide
Define security requirements while design choices remain openReview the pathways that could defeat the intended behaviourMake secure implementation expectations usableCombine review and testing according to the riskProtect development and test environments deliberatelyMake release approval a decision about evidence and exposureControl the full change, including configuration and infrastructureKeep outsourced development within the control modelHypothetical example: a commerce platform adds a partner integrationHypothetical example: an industrial analytics company changes a data pipelineProvide an emergency route with disciplined follow-upUse production feedback to improve the development systemFrequently asked questionsRelated ISO 27001 guides

Secure development makes information security part of design, implementation, testing, release and maintenance. It should help teams identify significant risks early and make accountable decisions when a change introduces exposure. For ISO 27001, the aim is a repeatable development and change process with appropriate controls and evidence, rather than a final security scan added just before launch.

Annex A contains reference controls relevant to secure development, architecture, coding, testing, environments, outsourced development and change, particularly A.8.25 to A.8.33. Their necessity follows risk treatment in the licensed ISO/IEC 27001:2022 standard. The engineering practices described below are recommendations to adapt to the service, technology and consequence; no particular development methodology or scanning product is universally prescribed.

Define security requirements while design choices remain open

Begin with the information, users, trust boundaries and business commitments affected by the proposed feature. Identify what must remain confidential, correct and available. Include administrative functions, integration behaviour and failure conditions. A clear requirement can influence architecture before the team has invested heavily in a design that is difficult to change.

Translate business needs into testable expectations. If one customer must not access another’s records, define the relevant isolation boundary and test scenarios. If an administrator can change sensitive configuration, define authorisation and accountability. Avoid broad statements such as “the application must be secure” that provide no basis for design or acceptance.

Maintain a route for requirements from contracts, incidents and risk assessments. A new customer may require a particular assurance outcome, while an incident may reveal a design assumption that needs revision. Product and engineering owners should understand these inputs and resolve conflicts before committing to delivery dates.

Review the pathways that could defeat the intended behaviour

Use a proportionate design review to examine how information crosses boundaries and how misuse or failure could occur. A simple data flow and discussion may be sufficient for a modest change. A major identity, payment or multi-tenant architecture change may require deeper analysis and specialist involvement. The review method should follow consequence and complexity.

Ask about assumptions. Which component verifies identity? Which service checks authorisation? What happens when a dependency is unavailable? Can a support user bypass a restriction? Are security decisions based on data controlled by an untrusted party? These questions help identify design weaknesses that a code scan may not recognise.

Record the important decisions and resulting actions. The purpose is not to produce a diagram for its own sake, but to preserve the reasoning and ensure that necessary changes enter delivery. Revisit the analysis when the design changes materially rather than treating the initial review as a permanent approval.

Make secure implementation expectations usable

Provide engineering guidance suited to the languages, platforms and patterns actually used. Approved libraries, service templates and examples can reduce repeated mistakes. The guidance should explain when a pattern is appropriate and where developers should seek review for unusual cases. A long generic coding policy is less useful if it does not help with current work.

Address secrets, dependencies and build integrity as part of the implementation process. Determine how credentials are supplied, how third-party components are selected and how changes to build configuration are controlled. An application can be carefully coded while its deployment pathway remains vulnerable to unauthorised alteration.

Maintain ownership of the guidance. Technical patterns evolve, and obsolete examples can create risk. Use findings from testing, incidents and engineering feedback to update the supported approach. Communicate significant changes to the teams that use it and check whether older services need treatment.

Combine review and testing according to the risk

Different methods reveal different problems. Peer review can examine design intent and implementation choices. Automated analysis can identify selected patterns at scale. Dependency review can expose component issues. Dynamic tests and specialist assessments can examine running behaviour. No single method should be presented as proof that every security weakness has been found.

Define test coverage and limitations. Identify the feature, environment, roles and data used, along with scenarios deliberately excluded. A test performed only as an administrator may miss user-level authorisation issues. A scan of a public endpoint may not examine internal workflows or configuration. Review whether the method addresses the risks introduced by the change.

Prioritise findings using context. Technical severity matters, but service exposure, exploitability, affected information and existing protections also influence the decision. Keep unresolved material findings visible to an authorised owner. Do not reclassify a finding solely to meet a release deadline.

Protect development and test environments deliberately

Development environments can contain source code, credentials, production-like information and deployment permissions. Define access and separation according to the risk. Avoid assuming that a non-production label makes the environment unimportant. A compromised build account or leaked test secret may affect production directly.

Use appropriate test data and control any necessary use of sensitive information. Determine the purpose, approval, protection and disposal requirements. Where synthetic or anonymised data is used, verify that it supports the intended tests and that the transformation does not leave unnecessary exposure. Legal and privacy questions should be resolved by the relevant qualified owners.

Control movement between environments. Identify who can promote changes, what evidence is required and how deployment credentials are protected. The process should prevent unreviewed work from reaching production while allowing authorised emergency changes through a defined route.

Make release approval a decision about evidence and exposure

A release decision should consider whether the agreed security requirements and acceptance criteria have been met. The reviewer needs the relevant test results, unresolved findings, known limitations and operating readiness. Avoid a generic approval that hides the difference between a minor configuration update and a major change in customer information handling.

Define who may accept residual exposure and within what limits. Engineering may confirm technical completion, while a service or risk owner decides whether a known limitation is acceptable. Keep those roles connected. A release manager should not be expected to accept an unfamiliar business consequence merely because the deployment window is closing.

Record conditions attached to approval. A limited rollout, additional monitoring or a time-bound follow-up may be part of the decision. Confirm that the operating team receives those conditions and that they are tracked after deployment. Otherwise, a carefully qualified approval can become an unqualified production state.

Control the full change, including configuration and infrastructure

Security-relevant changes extend beyond application code. Identity rules, network settings, cloud permissions, deployment pipelines and provider integrations can alter exposure. Include them in a proportionate change process with clear authority, impact consideration and evidence. The mechanism may differ by platform, but the decision needs remain.

Plan rollback or recovery appropriate to the change. Reverting code may not reverse a database transformation or information disclosure. Understand what can be undone, what must be restored and what conditions require stopping the rollout. Test the important assumptions where the consequence warrants it.

After deployment, verify the actual state and intended behaviour. Compare the release with the approved design and examine unexpected effects. Changes made during troubleshooting should be reconciled and reviewed rather than left as undocumented permanent adjustments.

Keep outsourced development within the control model

Agree security responsibilities with external developers before work starts. Define requirements, access, code ownership, component use, testing evidence, defect handling and delivery expectations appropriate to the engagement. A contract can establish obligations, but the organisation still needs to verify that the delivered work supports its service and risk decisions.

Provide access according to the task and lifecycle. External teams may need repositories, test environments or issue systems without needing unrestricted production access. Control secrets and sensitive test data, and remove access when the engagement changes or ends. Identify who approves exceptions and receives evidence.

Review the delivered artefacts and operating knowledge. Source code alone may not provide the configuration, build process, dependency information or support instructions needed to maintain the service. Plan handover and acceptance so that the organisation does not inherit a critical capability it cannot operate or assess.

Hypothetical example: a commerce platform adds a partner integration

A hypothetical commerce platform adds an integration through which partners can update order information. The initial project plan focuses on functionality and delivery dates. A design review identifies a risk that partner credentials could be used to alter another partner’s orders if authorisation relies only on an identifier supplied in the request.

The team defines the required trust boundary and adds tests covering valid access, cross-partner requests, revoked credentials and malformed input. Review examines both application logic and the administrative process for issuing credentials. The release record includes test evidence and the remaining operational requirements for monitoring and revocation.

A pilot reveals that support staff need a safe way to investigate failed requests without sharing active credentials. The team adds a diagnostic method before broad rollout. Security work changes the design and support process while the feature is still manageable, rather than relying on a final scan to discover a business logic problem.

Hypothetical example: an industrial analytics company changes a data pipeline

A hypothetical industrial analytics provider updates a pipeline that transforms equipment readings into customer reports. The change does not introduce a new login page, so the team initially considers it low security relevance. Risk review highlights integrity and availability: an incorrect transformation could produce misleading operational information across several customers.

The team defines validation criteria using representative data, expected transformations and error handling. It separates test data from live feeds and plans a staged deployment with comparison of old and new outputs. The service owner agrees the conditions for stopping rollout and the evidence required before expansion.

Testing reveals that one unusual unit conversion is handled incorrectly. The defect is corrected and the scenario becomes a regression test. The release evidence shows why the change is acceptable for the selected service, demonstrating that secure development includes trustworthy processing and controlled change, not only protection against unauthorised login.

Provide an emergency route with disciplined follow-up

Urgent repairs may need a faster approval and testing path, but define the minimum decision information and authority. The route should identify what can be deferred, what cannot and who accepts the immediate exposure. Make it accessible during an incident rather than requiring a process that depends on unavailable systems or people.

After the urgent action, complete the necessary review, testing and documentation. Remove temporary permissions and reconcile configuration. Examine whether the emergency arose from a recurring weakness that needs permanent treatment. A succession of emergency changes may indicate a delivery or resilience problem rather than isolated exceptional work.

Retain evidence honestly. Record what was known and tested at the time, and what was established later. Do not create a retrospective record that implies normal pre-release approval occurred when it did not. Accurate sequence and reasoning support learning and accountable assurance.

Use production feedback to improve the development system

Connect incidents, vulnerabilities and operational failures back to requirements, patterns and tests. Ask whether the issue arose from design, implementation, review, deployment or unclear ownership. A fix to one defect may be necessary, while a broader change prevents similar defects from entering other services.

Track measures that support decisions: material findings discovered late, repeated defect classes, overdue accepted issues and failures of deployment controls. Interpret them in context. More findings can reflect improved testing rather than worse engineering, and fewer findings can reflect reduced coverage. The report should explain what action is needed.

For support aligning development controls with an ISO 27001 information security management system (ISMS), see CyberVantage360’s implementation service or discuss a release or engineering assurance challenge. Share the service, delivery model and decisions that currently lack clear evidence.

Frequently asked questions

Does ISO 27001 require a specific development methodology?

No single methodology is universally prescribed. The organisation should determine necessary controls and integrate them into the way it develops and changes services. Agile, iterative and other delivery models can support appropriate security requirements, review, testing and accountable release decisions.

Is a vulnerability scan enough before release?

A scan can support selected checks but may not assess design assumptions, business logic, authorisation or operating readiness. Choose review and testing methods that address the risks introduced by the change, and record their scope and limitations.

Do configuration changes need security consideration?

Yes, where they can affect information security. Changes to identity, cloud permissions, networks, pipelines or integrations can materially alter exposure without changing application code. Use proportionate impact review, authority and evidence for the actual change.

Can emergency changes bypass all normal controls?

An emergency route can be faster, but it should retain defined authority, essential risk consideration and appropriate evidence. Deferred activities need follow-up. Urgency is a reason to design a usable alternative process, not to leave the resulting production state unexplained.