- 01
Market
Saudi Arabia
- 02
Written for
CTO, CISO
- 03
Decision
Build security into the delivery lifecycle
- 04
Languages
EN · AR
Security across the lifecycle
The four points where security enters the delivery lifecycle
Security is cheapest where the decision is still being made and most expensive after release. These are the points at which it enters the work, moving from a drawing to a running check to a line in the definition of done.
A lifecycle: threat modelling at design, security acceptance criteria in the story, dependency and secret checks in CI, and a focused review before release — with the failure mode of security living in tools but not in the definition of done.
- 01
At design — threat modelling
Before code exists, the team draws the design and asks how it could be attacked, so a missing boundary is a line on a whiteboard rather than a finding in production.
- 02
In the story — acceptance criteria
Each story carries the security conditions it must meet to be done — this input is validated server-side, this action is authorised, this data is not logged — so safe is part of finished, not a later pass.
- 03
In CI — dependency and secret checks
Every change runs against scanners for known-vulnerable components and committed secrets, so a bad artefact is stopped at the merge rather than shipped and found later.
- 04
Before release — a focused review
What the earlier steps could not settle — the interaction between components, the runtime configuration — gets a targeted review, small because most risk was already handled upstream.
When done does not include safe
If security lives only in tools and not in the definition of done, a story ships the moment it works, and security becomes a queue of findings chased after release. The tools stay; what changes is that a story is not finished until its security criteria are met.
Tools against practice
The difference between installing tools and changing the definition of done
A team can buy every tool in the category — a static analyser, a dependency scanner, a secret detector, a dynamic scanner — wire them into the pipeline, and still ship insecure software. The tools produce findings; whether anything changes depends on whether a finding stops a release, whether a developer is expected to clear it before the story is done, and whether the design was examined for risk before any of it was built. Tools without that discipline become a dashboard nobody is accountable to, and a dashboard is not a lifecycle.
The change that makes a lifecycle secure is to the definition of done. When a story is not finished until its security acceptance criteria are met, and when a design is not approved until it has been threat modelled, security stops being a stage that happens to code and becomes a property the team builds into it. That is a change in how the team works, not a purchase, which is why the valuable part of this engagement is the facilitation and the criteria, not the licence keys.
The practices
Four secure-lifecycle practices and what each adds to done
Each practice enters at a different point in delivery and adds a specific condition to what finished means. Adopting them is a change to process, not only to tooling.
Threat modelling at design
A short workshop over the design of a feature before it is built, asking how it could be misused.
What it adds to the definition of done: A design is not approved until the obvious attacks against it have an answer.
Security acceptance criteria
A security line added to the story alongside the functional acceptance criteria.
What it adds to the definition of done: A story cannot be marked done while a security condition is unmet.
Dependency and secret scanning in CI
Automated checks on every change for known-vulnerable components and committed credentials.
What it adds to the definition of done: A known-bad artefact or a leaked secret cannot merge in the first place.
A pre-release review, kept small
A focused check of what design and CI could not settle — component interaction, runtime configuration.
What it adds to the definition of done: A final gate that is quick because most risk was handled upstream.
Our role
What we set up in the lifecycle and what your team must own to keep it
- 01
We facilitate the practice, not just the tools
We run the first threat models with your team, write the initial security acceptance criteria, and wire the CI checks — but the point is that your team learns to do each without us, because a practice a supplier runs is a dependency.
- 02
We change the definition of done with you
Which criteria block a story, who owns the threat model, how a finding is tracked to closure — these are agreed and written into how the team works, because that is where a lifecycle becomes secure rather than merely instrumented.
- 03
Testing the running system stays necessary
A secure lifecycle reduces what a later test finds; it does not replace it. We say plainly that the running, configured system still needs periodic assessment, because some risk only appears once the parts are deployed together.
Which security conditions your team accepts as blocking, and how strict the definition of done becomes, are your decisions; we facilitate the practices, wire the checks, and hand the whole lifecycle over in a form your team runs without us.
Common questions
What buyers ask
We have already added security scanners to our pipeline. Is that a secure SDLC?+
It is a component of one, and often the easiest part. The scanners produce findings, but a secure lifecycle is defined by what those findings do: whether a finding blocks a merge or only fills a dashboard, whether a developer is expected to clear it before the story is marked done, and whether the design was examined for risk before any code was written. If a story can still ship the moment it works, regardless of what the scanner said, the tools are installed but the lifecycle is not secure. The change that matters is to the definition of done — that a story is not finished until its security criteria are met — and that is a change to how the team works, not a purchase.
When in a project should the first threat model be done?+
At design, before the code that implements the design exists — that is the entire point of it. A threat model is a structured conversation over how a feature could be attacked, and it is cheapest and most useful when the answer to a discovered risk is still a change to a diagram rather than a rewrite of shipped code. Run it too late and it becomes an audit of decisions already made and expensive to reverse. That does not mean it happens once: a design changes, and a threat model is refreshed when the shape of the system changes materially. But the first pass belongs at design, and a feature whose design has not been threat modelled is a feature whose risks are being discovered in the order an attacker finds them.
Does a secure development lifecycle remove the need for penetration testing?+
No, and we would distrust anyone who claimed it did. A secure lifecycle reduces the number and severity of what a later test finds, because most risk is handled where it is cheapest — at design and in the pipeline. What it cannot do is see how the parts behave once they are deployed and configured together, which is where a class of issue only appears: an interaction between two components each individually sound, a runtime configuration that undoes a code-level control, an exposure created by the environment rather than the code. Periodic testing of the running system remains necessary. The lifecycle changes the test from a wall of findings into a short list of the things that genuinely could only be found at runtime.
In this cluster
Next step
Review your lifecycle with us
A review of your delivery lifecycle that returns where threat modelling, CI checks and acceptance criteria belong, and how the definition of done changes so security is built in rather than inspected in.
Review your lifecycle with us
What happens next
- 1We reply within one business day.
- 2A 30-minute scoping call with a senior consultant.
- 3A written proposal with scope, team, and timeline.
Or reach us directly

