.png)
A software development methodology is the agreed operating model a team uses to turn an idea into working, maintained software. It sets how work is planned, sequenced, built, tested, released and reviewed, who decides what, and how progress and quality are measured. Common examples are Waterfall, Scrum, Kanban, Lean and DevOps.
No methodology is best in general. The right one depends on how stable your requirements are, how much a late change costs, how regulated your domain is, and how mature your engineering practices are. Most teams today run a deliberate hybrid: Digital.ai's 18th State of Agile Report (October 2025) found 74% of respondents use hybrid, blended or homegrown Agile models.
AI coding tools have not replaced methodology. They have made it matter more. The 2025 DORA report (September 2025, nearly 5,000 respondents) calls AI an amplifier: teams with loosely coupled systems and fast feedback gain from it, while teams with slow, tightly coupled processes see little or no benefit.
This guide is written for CTOs, VPs of Engineering, delivery leaders and product owners who have to choose, fix or defend a way of working. It covers:
This guide draws on published work and delivery experience from Forte Group's technology and delivery leaders:
A software development methodology is a shared set of principles, roles, events, artifacts and rules that governs how a team moves from a problem to deployed, maintainable software. It answers five questions every delivery effort has to settle, whether or not anyone writes the answers down:
A useful way to think about it: a methodology is a theory of where risk lives in your project, plus a plan for retiring that risk in the right order. Waterfall assumes the biggest risk is building the wrong thing at scale, so it front-loads specification. Scrum assumes the biggest risk is learning too late, so it shortens the loop. DevOps assumes the biggest risk sits between "done" and "running in production", so it automates that gap.
These four terms are often used interchangeably, which causes confusion in vendor conversations and job descriptions. They sit at different levels.
Two points are worth calling out. First, Agile is not a methodology. It is a set of four values and twelve principles published in the Manifesto for Agile Software Development in 2001. Scrum, Kanban and XP are ways of putting those values into practice. Second, the SDLC is not a methodology either. Every methodology runs through the same stages. What differs is the order, the overlap and the size of each pass.
When a team says it "uses" a methodology, these are the things it should be able to point to:
If a team cannot name these, it does not have a methodology. It has habits.
Methodology choice shows up directly in cost, risk and time to value. A mismatched approach causes rework, missed regulatory evidence, slow feedback and burned-out teams. The 18th State of Agile Report found that 76% of respondents face more scrutiny on the business impact of Agile, yet only about half feel they can deliver reliably and with accountability. The gap is rarely the framework itself. It is usually the fit between framework, context and engineering discipline.
Forte Group's Chief Delivery Officer, Egor Goryachkin, points to one gap in particular: quality assurance is often a weak spot in Agile teams. His view is that QA has to be shifted left, automated and structured, and should check whether the product feels right to users, not only whether it works. A methodology that is silent on quality will not fix this on its own.
Every methodology was a response to the failures of the one before it. Sequential methods answered the chaos of early, undisciplined programming. Iterative and Agile methods answered the late surprises of big up-front plans. DevOps answered the wall between "done" and "running". AI-native delivery is now answering a new problem: individual speed that does not reach the team. Knowing which problem a method was designed to solve tells you when it still fits.
Two lessons stand out. First, the field has repeatedly rediscovered iteration: Royce recommended it in 1970, decades before Agile made it mainstream. Second, each wave kept what worked from the last. Scrum still has a plan; DevOps still has phases; AI-native delivery still needs human gates. The best methodologies today are deliberate combinations of these layers.
The sixteen methodologies below fall into five families. Each entry gives a one-line definition, how it works, where it fits, where it breaks, and a decision signal you can test against your own project.
Sequential methodologies complete each phase before the next starts. They trade adaptability for predictability and a clear audit trail.
Definition: Waterfall is a linear methodology in which requirements, design, implementation, testing, deployment and maintenance happen in strict order, each signed off before the next begins.
How Waterfall works: Most of the thinking happens early. A detailed specification becomes the contract for design and build, and testing happens after the code is complete. Change requests go through formal change control.
History worth knowing: Waterfall is usually traced to Winston Royce's 1970 paper, "Managing the Development of Large Software Systems". Royce never used the word "waterfall". He described the single-pass sequence and then warned that it was risky and invited failure, recommending feedback loops and building the system twice. The industry adopted the diagram and skipped the warning.
Waterfall fits: Fixed-scope contracts, stable and well-understood requirements, regulatory submissions that need a complete design before build, and work tied to physical infrastructure that cannot be released in slices.
Waterfall breaks: When requirements, markets or technology shift mid-project. Defects found late are expensive, and users see nothing until the end.
Decision signal: If your requirements document has legal or regulatory standing before development starts, Waterfall deserves serious consideration. If it does not, look elsewhere first.
Definition: The V-Model is an extension of Waterfall that pairs every specification phase with a matching test phase, so test planning happens alongside design rather than after coding.
How the V-Model works: The left side of the V descends through requirements, system design, architecture and module design. The right side climbs through unit, integration, system and acceptance testing. Each level of the right side verifies the matching level on the left.
The V-Model fits: Safety-critical and heavily regulated software, such as medical devices, automotive, aerospace and industrial control, where traceability from requirement to test is mandatory.
The V-Model breaks: Same rigidity as Waterfall, with more documentation overhead. Late changes ripple across both sides of the V.
Decision signal: Choose it when an auditor will ask you to prove that every requirement has a test, and every test traces to a requirement.
These methodologies build the system in repeated passes. They appeared because single-pass delivery kept failing on large, uncertain projects.
Definition: Incremental development delivers a system in working slices, each adding functionality, while iterative development refines the same slice through repeated cycles. Most modern methods combine the two.
How incremental development works: The team plans the overall architecture, then builds and releases the highest-value increment first. Each increment goes through its own mini life cycle.
Incremental development fits: Long programs that need to deliver value early, and systems that can be split into modules with clean interfaces.
Incremental development breaks: Without a sound architecture up front, later increments collide with earlier ones. Integration debt builds up.
Decision signal: If users can benefit from part of the system before all of it exists, deliver incrementally.
Definition: Spiral is a risk-driven model, introduced by Barry Boehm in the 1980s, in which each loop of development starts by identifying and reducing the largest remaining risk before more is built.
How Spiral works: Each loop has four quadrants: set objectives, analyse and reduce risk (often with a prototype), develop and test, then plan the next loop. The system grows outward with each turn.
Spiral fits: Large, high-uncertainty programs with novel technology or high cost of failure, such as defense, platforms and first-of-kind systems.
Spiral breaks: It depends on skilled risk analysis. Without it, Spiral turns into open-ended iteration with no clear end date or budget.
Decision signal: Use Spiral thinking when you genuinely do not know what you do not know. Most teams borrow its risk-first loop inside a hybrid rather than running it pure.
Definition: Prototyping builds quick, often throwaway versions of a system to clarify requirements with users before committing to a full build.
How prototyping works: The team builds a mock-up or partial system, gathers feedback, refines it, and repeats until requirements are stable. Prototypes can be throwaway or evolve into the product.
Prototyping fits: User-facing products where needs are vague, novel interfaces, and stakeholder alignment in early discovery.
Prototyping breaks: Stakeholders mistake a prototype for a nearly finished product. Throwaway code slips into production.
Decision signal: Prototype when the cheapest way to learn what users want is to show them something. Decide in writing whether the prototype will be discarded.
Definition: RAD, popularised by James Martin in 1991, compresses planning in favour of rapid prototyping, user workshops and reuse of existing components to deliver working software fast.
How RAD works: Short requirements workshops feed a user-design phase of repeated prototyping, followed by rapid construction and cutover. Small, skilled teams build modules in parallel.
RAD fits: Internal tools, MVPs and modular business applications with engaged users and modest scale.
RAD breaks: At large scale, under heavy compliance, or when architecture is an afterthought. The most expensive sentence in RAD is "we'll clean it up later".
Decision signal: Use RAD for bounded, low-risk applications. Add an explicit architecture review before any RAD build reaches production infrastructure.
Agile methodologies deliver working software in short cycles, keep the customer close, and treat change as normal rather than as a failure of planning. They all trace back to the four values of the Agile Manifesto: individuals and interactions over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan. The manifesto is explicit that the items on the right still have value; the items on the left are valued more.
Definition: Scrum is a lightweight framework in which a small, cross-functional team delivers a usable increment of product every Sprint, a fixed timebox of one month or less.
How Scrum works: The 2020 Scrum Guide defines three accountabilities (Product Owner, Scrum Master and Developers), five events (the Sprint, Sprint Planning, Daily Scrum, Sprint Review and Sprint Retrospective) and three artifacts (Product Backlog, Sprint Backlog and Increment), each with a commitment: the Product Goal, the Sprint Goal and the Definition of Done. The Guide describes a Scrum Team as typically 10 or fewer people. Two-week Sprints are the most common choice in practice.
Scrum fits: Product teams building customer-facing software with an engaged product owner and work that can be split into Sprint-sized slices.
Scrum breaks: Scrum says almost nothing about engineering practice. Teams that adopt the events without automated testing, CI and code review often just produce technical debt faster. It also struggles with interrupt-driven work such as support and operations.
Decision signal: Choose Scrum when you need a regular decision rhythm with stakeholders and someone with real authority over scope. If nobody can play Product Owner properly, fix that first.
Definition: Kanban is a flow-based method that visualises work on a board, limits work in progress (WIP), and improves delivery by managing flow rather than fixed iterations.
How Kanban works: Work items move across columns that mirror your real workflow. Each column has a WIP limit, so new work only starts when capacity frees up. Teams track lead time, cycle time and throughput, and change the process in small evolutionary steps. The Kanban Method for knowledge work was formalised by David J. Anderson in the late 2000s.
Kanban fits: Support, maintenance, platform and operations teams, and any work that arrives unpredictably. It also works as a first step for teams that cannot yet change roles.
Kanban breaks: Without WIP limits, Kanban is just a to-do board. Without a cadence for review, priorities drift.
Decision signal: If your team is constantly switching between urgent production issues and planned work, Kanban gives a more honest picture of throughput than Sprint velocity.
Definition: Scrumban is a hybrid that keeps some Scrum structure, such as planning and retrospectives, while managing day-to-day work through a Kanban board with WIP limits and pull-based planning.
How Scrumban works: Teams keep regular review and improvement events but replace fixed Sprint commitments with a continuously refilled queue. Planning triggers when the ready queue drops below a set level.
Scrumban fits: Teams that mix new feature work with support, or teams moving between Scrum and Kanban.
Scrumban breaks: It can become an excuse to drop the parts of Scrum that were uncomfortable but useful, such as a clear Sprint Goal.
Decision signal: Choose Scrumban when Sprint commitments keep breaking because of unplanned work, but you still want a review and improvement rhythm.
Definition: Extreme Programming is an Agile methodology, created by Kent Beck in the late 1990s, that pushes proven engineering practices to their limit to deliver high-quality software under changing requirements.
How XP works: XP prescribes concrete technical practices: test-driven development, pair programming, continuous integration, small releases, refactoring, simple design, collective code ownership and an on-site customer. It is the only mainstream Agile approach that mandates how code is written.
XP fits: Long-lived products with complex domain logic and frequent change, such as fintech, healthcare records and core business platforms.
XP breaks: It needs management backing for practices that look slower in the short term. Teams that adopt TDD and pairing half-heartedly tend to abandon them within months.
Decision signal: If your product must stay maintainable for years and defects are expensive, pair XP practices with whatever planning framework you use.
Definition: Feature-Driven Development is a model-driven Agile methodology, developed by Jeff De Luca in 1997, that organises work around small, client-valued features built in short iterations.
How FDD works: FDD runs five processes: develop an overall model, build a feature list, plan by feature, design by feature and build by feature. A feature should be small enough to deliver in about two weeks. Chief programmers and class owners give it more structure than Scrum.
FDD fits: Larger teams building complex business domains where a shared domain model is essential.
FDD breaks: It depends on strong chief programmers and an accurate domain model. It is rarely adopted whole today.
Decision signal: Borrow FDD's feature-centric decomposition when domain modelling must come before development.
Definition: DSDM is an Agile project delivery framework, now stewarded by the Agile Business Consortium, that fixes time, cost and quality and lets scope flex using MoSCoW prioritisation.
How DSDM works: Work is timeboxed, requirements are prioritised as Must, Should, Could or Won't have this time, and a defined project life cycle (pre-project, feasibility, foundations, evolutionary development and deployment) adds governance that many Agile frameworks lack.
DSDM fits: Fixed-deadline, fixed-budget projects in organisations that need Agile delivery with formal project governance.
DSDM breaks: It is heavier than Scrum, and MoSCoW only works if "Must" is genuinely limited.
Decision signal: Choose DSDM when a deadline cannot move and leadership expects project-style governance.
Definition: Crystal is a family of lightweight Agile methodologies, created by Alistair Cockburn, that scales its ceremony to team size and to how critical the system is.
How Crystal works: Variants are named by colour, from Crystal Clear for small co-located teams up to heavier variants for larger or more critical systems. Common properties include frequent delivery, reflective improvement and close communication.
Crystal fits: Small, experienced teams that want minimal process and are trusted to tailor it.
Crystal breaks: Its light prescription gives little guidance to inexperienced teams.
Decision signal: Crystal's core idea, matching process weight to team size and criticality, is worth using even if you never adopt Crystal by name.
Definition: Lean software development applies the principles of the Toyota Production System to software, focusing on removing waste and shortening the time from idea to value.
How Lean works: Mary and Tom Poppendieck adapted Lean for software in 2003 with seven principles: eliminate waste, build quality in, create knowledge, defer commitment, deliver fast, respect people and optimise the whole. Teams map the value stream from request to production and attack the biggest sources of delay. Typical software waste includes partially done work, extra features, handoffs, task switching, waiting and defects.
Lean fits: Any organisation whose delivery is slowed by process overhead rather than technical difficulty. It is less a methodology than a diagnostic lens you apply on top of one.
Lean breaks: When "Lean" becomes a cost-cutting label instead of a flow discipline, or when teams optimise their own step while the end-to-end flow stays slow.
Decision signal: Map your value stream before you change frameworks. Teams often find that most of their lead time is waiting for approvals, environments, reviews or releases.
Definition: DevOps is a set of cultural and technical practices that unifies development and operations so teams can build, test, release and run software continuously and reliably. DevSecOps adds security to every stage of that pipeline rather than at the end.
How DevOps and DevSecOps work: Teams own what they ship in production. Continuous integration and continuous delivery (CI/CD), infrastructure as code, automated testing, monitoring and fast feedback make small, frequent releases safe. DORA's research tracks delivery performance with measures such as change lead time, deployment frequency, change failure rate and time to recover. DevSecOps builds in threat modelling, static and dynamic security testing, dependency and secrets scanning, and policy as code.
DevOps and DevSecOps fit: Cloud-native products, SaaS, and any team that needs frequent, low-risk releases. DevSecOps is effectively mandatory where you handle personal, financial or health data.
DevOps and DevSecOps break: When it is treated as a tooling purchase. If a separate operations group still approves every deployment, you have a sequential process with better tools.
Decision signal: If developers can deploy and are accountable for what runs in production, you have the foundation for DevOps. If not, start there, not with the pipeline.
DevOps is also where AI-generated work lands. Forte Group CTO Lucas Hendrich notes that AI-generated code, documentation and infrastructure can sprawl quickly, and that DevOps functions are taking on more responsibility for observability and traceability as a result. His practical advice is to give DevOps and platform teams explicit ownership of that sprawl before it becomes a governance problem.
Definition: Scaled Agile frameworks coordinate many Agile teams working on one product or portfolio, adding planning, dependency management and governance layers that single-team frameworks do not provide.
How scaled frameworks work:
Scaled frameworks fit: Products that genuinely need several teams to deliver a single integrated increment, with real cross-team dependencies.
Scaled frameworks break: Heavy frameworks can recreate the bureaucracy Agile was meant to remove. Scaling a team-level problem simply makes it a bigger problem.
Decision signal: Before choosing a scaling framework, try to reduce dependencies through architecture and team design. Scale the framework only as far as the remaining dependencies require.
The table compares all sixteen methodologies on the factors that most often decide the choice. Ratings are relative and assume competent execution; they are an editorial synthesis, not survey data.
The practical takeaway: methodologies are not mutually exclusive. A common and healthy pattern is phase-gated governance for funding and compliance, Scrum or Kanban for delivery, XP practices for code quality, and DevSecOps for release. The skill lies in choosing each layer on purpose.
Choose a methodology by working from the constraints you cannot change toward the practices you can. The seven steps below take about an hour with your delivery lead, product owner and architect, and they produce a written decision you can revisit.
Forte Group's Four-Question Methodology Filter is a fast first pass for choosing a starting methodology. Ask four questions in order and stop at the first "yes":
If all four answers are "no", start with Scrum plus XP engineering practices, the default for a single product team. Whatever the result, every path needs a DevSecOps pipeline, a Definition of Done that covers AI-generated work, and a written decision record.
Methodology decision flow · 4 questions, 5 starting points
Treat the result as a starting point, not a verdict; the seven steps below refine it for your constraints, maturity and engagement model.
Start with regulation, contracts and fixed dates.
Score two things from low to high: how well you understand the requirements, and how well you understand the technology. Low on both suggests a plan-driven approach is safe. High on either calls for short feedback loops. High on both calls for risk-first iteration, such as Spiral thinking, prototypes and spikes, before you scale delivery.
A methodology can only move as fast as your engineering practice allows. Ask:
Each "no" is a prerequisite to fix, not a reason to pick a lighter methodology and hope.
One team on one product rarely needs a scaling framework. If several teams must integrate their work every increment, first try to cut dependencies through architecture and team boundaries. Add LeSS, Nexus or SAFe only for the coordination that remains.
When you work with a delivery partner, the engagement model decides who owns the methodology. Forte Group's Chief Delivery Officer, Egor Goryachkin, describes three models. In managed staff augmentation, the client runs the process and the partner is accountable for the people it places. In managed engineering services, the partner owns a distinct stream of work with its own backlog, tooling and cadence. In a managed product, the partner owns the whole life cycle, from roadmap to release management. The more ownership you hand over, the more the partner's methodology, metrics and quality gates matter, so ask to see them before you sign.
Record the decision like an architecture decision record:
An intentional hybrid is a strength. An accidental one, where teams pick up practices on impulse and drop them when they chafe, is the most common source of methodology failure.
AI has not made methodology obsolete. It has raised the cost of a weak one. AI tools speed up individual work, but unless the methodology changes how work moves between roles, that speed is absorbed by queues, reviews and rework downstream.
Forte Group's Chief AI Officer, Alex Lukashevich, argues that most organisations face a staging gap rather than a tooling gap. Teams stuck at the first stage try to jump straight to the third. In his words, "Augment gives you faster engineers. It does not give you a faster team."
The methodology lesson is that Automate is a process redesign, not a tool rollout. It means mapping where work stalls and where rework starts before configuring any tool.
Forte Group's delivery teams have reported several concrete changes from running AI-native delivery on client programmes.
Fewer roles, clearer ownership. On the Xceptor programme, Delivery Manager Yury Yurkou describes collapsing a relay of product, architecture, development, QA and DevOps handoffs into two roles. Product works with AI to shape and validate requirements; a Builder orchestrates AI through design, build, test and release and owns what ships. Speed came from removing waiting time between stages, not from removing checkpoints. Two connectors estimated at two weeks shipped in two days, and rework fell from about 30% to under 10%.
Story sizing flips. Yury reports that the textbook practice of splitting work into small, independently testable stories backfired for agents. Every story forces the agent to reload context, so a small story costs nearly as much as a large one. One larger story per connector worked better. Teams running Scrum with agents should revisit their sizing and estimation rules rather than assume human norms carry over.
Detail becomes a cost. Left alone, agents produce far more documentation than reviewers will read. Artifacts need to be calibrated to what a human will actually approve.
Autonomy is set per task, not per team. Delivery Manager and Technical Product Owner Slava Vlaskin describes giving every agent task a ticket with a written mission and choosing an autonomy level per ticket: plan only, build with human review of the plan and merge, or fully automatic for narrow, well-specified fixes. [EXPERT INPUT: Slava Vlaskin to confirm wording; link to his article once published.]
Team shape and roles change. CTO Lucas Hendrich observes that large teams of fifty or a hundred on one product are no longer the default, that engineers are moving toward end-to-end ownership of a working feature, and that QA is shifting toward reviewing and refining AI-generated test scripts. He also reports rising demand for product management talent, because product owners sit where technical delivery meets business value.
The points below are Forte Group's editorial synthesis of the evidence above, not survey findings.
Not everything is solved. Yury notes that regression testing an AI delivery pipeline remains an open problem: the agents are probabilistic, so a change to an instruction can make the next run worse, and validating a whole multi-stage pipeline after a change is not yet well supported by tooling. Lucas points to uneven readiness between modern and legacy stacks, a real upskilling curve for testers and specialists, and AI harnesses that still need tailoring per project. Methodologies will keep evolving as these gaps close.
Most methodology failures are not caused by picking the "wrong" framework. They come from running a framework without the conditions it assumes. The table lists the patterns we see most often, the symptom that gives each away, and the first fix to try.
The tool-first AI pattern is the newest on this list. Before Forte Group's engagement, the Xceptor team had GitHub Copilot rolled out and more than 18,000 recorded AI events over six months, yet nobody could tell whether delivery was improving, and rework sat around 30%. Yury Yurkou describes the diagnosis as a tool-first rollout into a process that had not been redesigned to use it.
Even a well-chosen, well-run methodology has limits worth stating plainly.
[EXPERT INPUT: Optional quote from Lucas Hendrich or Egor Goryachkin on the single most expensive methodology mistake they see in mid-market or PE-backed engineering organisations.
A software development methodology is the operating model a team uses to plan, build, test, release and maintain software. It defines the order of work, who makes which decisions, how feedback is gathered and what counts as done. Examples include Waterfall, Scrum, Kanban, Lean and DevOps.
The software development life cycle (SDLC) lists the stages all software passes through: requirements, design, build, test, deploy and operate. A methodology decides how you move through those stages: in one pass or many, in what size of slice, and with which checkpoints. Every methodology covers the same SDLC stages in a different way.
Agile is neither. It is a set of four values and twelve principles published in the Agile Manifesto in 2001. Scrum, Kanban, XP, DSDM and Crystal are frameworks or methodologies that put those values into practice. Saying a team "does Agile" says little until you know which of these it uses.
There are five broad families. Sequential methods (Waterfall, V-Model) plan up front and build once. Iterative methods (Incremental, Spiral, Prototyping, RAD) build in repeated passes. Agile frameworks (Scrum, Kanban, XP and others) use short feedback loops. Lean focuses on flow and waste. DevOps and scaled frameworks address release and multi-team coordination.
A methodology gives a team a shared answer to how work is sequenced, decided, checked and released. Without one, those answers are improvised for every feature, which causes inconsistent quality, unclear ownership and avoidable rework. A methodology also gives stakeholders a predictable way to see progress and intervene.
There is no fixed number, because new hybrids appear constantly. This guide covers the sixteen in widest use. In practice, most organisations combine elements of three or four, and the 18th State of Agile Report found 74% of respondents use hybrid, blended or homegrown models.
Waterfall is a sequential methodology in which each phase is completed and signed off before the next begins. Use it when requirements are stable and well understood, when a regulator or contract requires a complete specification before build, or when the work is tied to physical infrastructure that cannot be released in slices.
Not as it is usually practised. Royce's 1970 paper described a single-pass sequence of phases and then warned that it was risky and invited failure. He recommended iteration, feedback between phases and building a pilot version first. The term "waterfall" came later, and the industry largely adopted his diagram without his caveats.
Waterfall plans the whole project up front and delivers once at the end. Agile plans continuously and delivers working software in short cycles. Waterfall manages risk through specification and change control; Agile manages it through fast feedback. Waterfall suits stable, regulated work; Agile suits uncertain requirements and evolving products.
Scrum organises work into fixed-length Sprints with set roles and events, and commits to a Sprint Goal. Kanban manages a continuous flow of work on a board, limits work in progress, and has no required roles or iterations. Scrum suits planned product development; Kanban suits unpredictable, interrupt-driven work such as support and operations.
Agile focuses on how teams plan and build software in short, customer-focused cycles. DevOps focuses on getting that software into production and running it reliably, through shared ownership between development and operations, automation and fast feedback from production. They complement each other: Agile without DevOps tends to stall at release.
DevSecOps is DevOps with security built into every stage of the delivery pipeline instead of being checked at the end. It adds practices such as threat modelling, automated security testing, dependency and secrets scanning, and policy as code. It is effectively required wherever software handles personal, financial or health data.
No. Lean comes from manufacturing and focuses on eliminating waste and improving end-to-end flow. Agile comes from software and focuses on iterative delivery and collaboration. They share many ideas, and Kanban sits at their intersection. Lean is most useful as a lens for finding delays across the whole value stream.
A hybrid methodology deliberately combines elements of different approaches. A common example is phase-gated funding and compliance at the top, Scrum or Kanban for delivery, XP practices for code quality and DevSecOps for release. Hybrids work when each element is chosen on purpose and written down, and fail when practices are adopted and dropped at random.
Agile approaches dominate, and Scrum is widely reported as the most common team-level framework, often combined with Kanban. In practice, hybrids are now the norm: Digital.ai's 18th State of Agile Report (October 2025) found 74% of respondents use hybrid, blended or homegrown Agile models.
The Scrum Guide sets a maximum of one month. Two weeks is the most common choice because it balances planning overhead against feedback speed. Shorter Sprints suit fast-changing products and teams working heavily with AI agents; longer Sprints can suit work with long integration or approval cycles.
The 2020 Scrum Guide describes a Scrum Team as typically 10 or fewer people, including the Product Owner and Scrum Master. Larger groups should split into several Scrum Teams that share one Product Goal, Product Backlog and Product Owner.
Start with what you cannot change: regulation, contract model, funding cycle and fixed dates. Then rate how uncertain your requirements and technology are, name the shape of the work, check engineering maturity, and count the teams involved. Write the resulting hybrid down as a decision record and review it after two or three releases.
The Four-Question Methodology Filter is Forte Group's quick method for picking a starting methodology. Ask in order: is scope fixed by law or contract (Waterfall or V-Model), does work arrive unpredictably (Kanban), is the core risk still unknown (Spiral and prototypes), and are several teams on one product (Scrum plus LeSS, Nexus or SAFe)? If every answer is no, start with Scrum and XP practices.
Regulated industries usually need the traceability of the V-Model or Waterfall, but not necessarily their pace. Many teams combine V-Model documentation and verification for regulated components with iterative delivery and DevSecOps automation, so that the pipeline itself produces much of the audit evidence.
Lean thinking combined with Scrum or Kanban suits most startups, because the main risk is building something nobody wants. Rapid prototyping helps in early discovery. Add an explicit architecture checkpoint before the MVP becomes the production system, so that speed now does not become rework later.
Kanban usually fits best, because support work arrives unpredictably and cannot be planned into fixed Sprints. Work-in-progress limits and cycle-time tracking show where work gets stuck. Teams that mix support with feature work often use Scrumban or run separate Kanban and Scrum streams.
Large enterprises usually combine team-level Scrum or Kanban with a scaling framework such as SAFe, LeSS or Nexus. Before choosing one, reduce cross-team dependencies through architecture and team design. The less coordination you need, the lighter the scaling framework can be.
Yes, and it is often the right call when the current approach clearly does not fit. Change at a natural boundary such as a release, explain the reason to stakeholders, keep the metrics continuous so you can compare before and after, and change one layer at a time rather than everything at once.
Measure outcomes and flow, not ceremonies. Useful measures include lead time for changes, deployment frequency, change failure rate, recovery time, rework rate, escaped defects and customer satisfaction. Compare against your own baseline. Avoid using velocity or story points as a performance target, because they inflate once people are judged on them.
It depends on the engagement model. With staff augmentation, you run the methodology and the partner supplies people. With managed engineering services, the partner runs a defined stream with its own cadence. With a managed product, the partner owns the full life cycle. The more you hand over, the more you should scrutinise the partner's methodology and quality gates.
Ask how they decide between methodologies, and for an example where they did not use Scrum. Ask what their Definition of Done includes, how quality is built in, which delivery metrics they report, how they handle changing requirements in a fixed budget, and how AI-generated work is reviewed and governed.
AI speeds up individual tasks but amplifies whatever system it enters. The 2025 DORA report found teams with fast feedback and loosely coupled systems gain, while slow, tightly coupled processes see little benefit. Methodologies therefore need redesigned handoffs, review-focused roles, AI-aware definitions of done and clear governance, not just new tools.
Yes, but its details change. Scrum's empirical loop of inspecting and adapting becomes more useful when output volume rises. What changes is story sizing, Sprint length, the Product Owner's weight and the Definition of Done, which should say how AI-generated code, tests and documents are reviewed.
AI-native development redesigns the delivery life cycle so AI agents produce artifacts across stages, such as requirements, code, tests and release notes, while humans review and approve at defined gates. It differs from simply giving developers a coding assistant, which speeds up individuals without changing how work flows between roles.
Spec-driven development treats a written specification as the main input that AI agents build from and as the main control point for reviewers. Because agents build what the specification says, gaps in it, including missing security or compliance requirements, become gaps in the product. The specification therefore needs the same rigour as code.
Decide per task, not per team. Narrow, well-specified changes with strong automated tests and review can run end to end. Ambiguous or high-risk work should keep human approval of the plan and the merge. Start with read-only or plan-only autonomy and widen it as measured quality earns trust.
If your teams have adopted AI tools but delivery metrics have not moved, or you are deciding how a partner should run your next build, we can help you map where work stalls and design the hybrid that fits. [EXPERT INPUT: link to conversion asset, for example the AI-Enabled Software Delivery service page or a delivery-model workshop]
Talk to Egor Goryachkin about choosing a delivery methodology, or to Alex Lukashevich about moving from AI pilots to AI-native delivery.