Making Progress in Stages: Incremental Decision Models

UPI Study › Courses › Software Engineering › Free lessons › Lesson 2.2 Free with a free account

Making Progress in Stages: Incremental Decision Models

Software Engineering · Chapter 2: Iterative, Incremental, and Specialized Process ModelsSection 2.2 · lesson 12 of 1036 min · free with a free account

← Building Software in Cycles: The Iterative ApproachNext lesson: Managing Risk Through the Spiral Process →

Earn 3 college credits for Software EngineeringRecommended for credit by NCCRS · Computer Science 301 · self-paced · one payment, lifetime access
Enroll in Software Engineering · $250 →Download the syllabus (PDF)

In this lesson

The incremental model: functional builds, and the decisions between them.

  • Describe the incremental model and its functional builds
  • Distinguish incremental delivery from pure iteration
  • Explain what happens at a decision point, and why it matters
  • Recognize when building in stages is the better fit

Transcript

Everything said in the video, section by section (782 words). Read along, or search it.

Iterative, Incremental, and Specialized Process Models

Making Progress in Stages

What if you did not have to get everything right, before you built anything at all? This section introduces the incremental model, which delivers software in stages. It covers what makes a build an increment, how incremental delivery differs from iteration, and the decision points between increments.

2 Teams, 1 Feature

One Big Leap, or Working Pieces?

Picture two teams asked to build the same order-tracking feature for an online store. The first team disappears for four months, and returns with the entire feature finished, all at once. The second team returns after three weeks with a small, working piece. Customers can now see whether an order has shipped. Nothing else is built yet. But what exists actually runs, and real users can try it. The second team is working the way the incremental model describes. The system is split into a sequence of smaller pieces, called increments. Each is designed, built, tested, and delivered as a complete, usable build, before work on the next increment begins.

Figure 1

Increments Accumulate

Here is how the order-tracking feature grows. Increment one handles only shipped-status lookups. Increment two adds delivery estimates, and increment three adds live carrier tracking. Notice that each build keeps everything before it. By the last increment, shipped status and delivery estimates are still there, working alongside the new tracking. And between every pair of increments sits a decision point.

Table 1

What Makes a Build an Increment

The defining feature of an increment is that it is functional. Increment one is not a sketch, a mockup, or a throwaway prototype. It is a smaller version of the real system, already doing something useful from end to end. Increments accumulate. Each one adds to what earlier increments delivered, rather than replacing it. Order can matter. Increments are often sequenced so the most essential capability ships first. And scope shrinks up front. Each increment is small enough to plan and build with reasonable confidence.

Table 2

Incremental Is Not the Same as Iterative

Incremental and iterative get used loosely enough that they start to sound interchangeable. In this model, they mean different things. Pure iteration repeats a cycle of work, plan, build, review, and refine, without requiring each cycle to produce something a user could run. An iteration can exist purely to improve internal design, or work through a difficult algorithm. Incremental delivery adds a stricter requirement. Whatever comes out of the cycle has to be a working, deliverable build. Iteration often reworks the same piece. An increment adds new capability on top of what already works. Every increment is produced through some iterative work. But not every iteration results in an increment.

Think About It

Is This an Increment?

Here is a test case. A team spends two weeks reworking how its database queries are structured. Nothing the user sees has changed. Is that an increment? By the definition, no. It is iterative refinement. It becomes part of an increment only once it is bundled into a build, that also delivers something new, and usable.

Decision Points

Look at a Real Build, Then Decide

Because each increment ends with something real and working, it creates a natural pause that pure iteration does not. The people responsible can look at an actual build, not a plan or a projection, before committing to what comes next. That pause is the decision point. It is not a formality. The review is grounded in how the build actually behaves. It typically ends in one of three directions. Continue as planned. The increment met expectations, and the next proceeds as originally scoped. Adjust the scope of the next build. Something learned from the delivered increment changes what the next one should include. Or stop. The increments delivered so far already meet the need.

The Easily Missed Option

Stopping Early Leaves Nothing Broken

That third option is easy to overlook, but important. Because every increment is already usable on its own, a project built this way can end earlier than planned, without leaving anything broken or unfinished. Whatever has shipped by that point still works. Stop after increment two, and customers still have shipped status, and delivery estimates. A working system, not a half-built one.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. The incremental model delivers software as a sequence of smaller, functional builds, each adding to what came before. An increment is one complete, working, usable build. Pure iteration repeats a cycle to refine or improve something, without requiring each result to be usable on its own. And a decision point is the review after a delivered increment, where the plan is continued, adjusted, or stopped.

Key Takeaways

What to Carry Forward

To pull this together. The incremental model delivers software as a sequence of smaller, functional builds, rather than one complete system at the end. Each increment must be usable on its own, which iteration alone does not guarantee. A decision point follows every increment, and can continue, adjust, or stop the plan. And because early increments already work, stopping partway through still leaves behind a usable system.

About Software Engineering at UPI Study

Software Engineering (Computer Science 301) is a self-paced online course of 103 video lessons in 15 chapters, from process models and agile to requirements, design, user interfaces, reliability, security and project management. It carries a NCCRS credit recommendation for 3 semester credits.

Every lesson transcript is free on pages like this one, and the videos are free with a free UPI Study account. Enrolling adds a practice quiz after each lesson, the graded work and final exam that earn the credit, lifetime access, and an official transcript on completion. UPI Study has helped over 130,000 students with college credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Enroll now → Course details Download the syllabus All Computer Science courses Every course with PRO →

Compare: Software Engineering vs Systems Analysis

Why take it here

Why students take Software Engineering with UPI Study

How professional software gets builtSoftware Engineering covers how teams turn requirements into working, maintainable software: process models, agile, requirements, design, testing, reliability and project management. It is a core course in computer science and software degrees.
Credit at a fraction of the priceThe same 3 credits can cost $750 or more at a US college. Here it is one payment, self-paced, with lifetime access.
Finish your degree soonerTransfer credits reduce the courses you still owe, so you can graduate earlier or lighten a heavy semester.
Strengthen an applicationA completed college-level course on an official transcript shows admissions and scholarship committees you can do the work.
Study on your own scheduleNo start dates, no deadlines. Watch the lessons, practice, and take the final when you are ready.
130,000+students helped with college creditsACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Where the credit goes

Universities that work with NCCRS

Software Engineering carries a NCCRS credit recommendation. These universities work with NCCRS; some are UPI Study's signed partners. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Thomas Edison State UniversityThomas Edison State UniversitySigned partnerUniversity of the PeopleUniversity of the PeopleSigned partnerCharter Oak State CollegeCharter Oak State CollegeSigned partnerStrayer UniversityStrayer UniversitySigned partnerColumbia Southern UniversityColumbia Southern UniversitySigned partnerIndiana TechIndiana TechSigned partnerPenn StatePenn StateWorks with NCCRSSouthern New Hampshire UniversitySouthern New Hampshire UniversityWorks with NCCRSSUNYSUNYWorks with NCCRS +many more cooperating universitiesFind my college →

Find my college → Not listed? Ask Athena in the corner of this page, or book a 15-minute call.

FAQ

Questions students ask us

About Making Progress in Stages: Incremental Decision Models

What is the incremental model in software engineering?
The incremental model delivers software as a sequence of smaller, functional builds called increments. Each increment is designed, built, tested and delivered as a complete, usable build before the next begins, and each adds to what earlier increments delivered. An order-tracking feature, for example, might ship shipped-status lookups first, then delivery estimates, then live carrier tracking.
What is the difference between incremental and iterative development?
Iterative development repeats a cycle of planning, building, reviewing and refining without requiring each cycle to produce something a user can run, while incremental development requires every cycle to deliver a working, usable build. Iteration often reworks the same piece; an increment adds new capability on top of what already works. Every increment involves iterative work, but not every iteration yields an increment.
What happens at a decision point in the incremental model?
A decision point is the review after each delivered increment, where the people responsible examine an actual working build before committing to the next. It typically ends in one of three directions: continue as planned, adjust the scope of the next build based on what was learned, or stop because the increments delivered so far already meet the need.
Can an incremental project stop early without failing?
Yes. Because every increment is usable on its own, a project built incrementally can end earlier than planned without leaving anything broken or unfinished. Whatever has shipped still works. If an order-tracking project stopped after its second increment, customers would still have shipped status and delivery estimates, a working system rather than a half-built one.

About the Software Engineering course

How many college credits is Software Engineering?
Software Engineering (Computer Science 301) carries a NCCRS credit recommendation for 3 semester credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.
How much does Software Engineering cost and what is included?
$250, paid once, with lifetime access: all 103 video lessons, a practice quiz after each, the graded work and final exam, and an official transcript when you finish. Students who want several courses choose UPI Study PRO instead.
Which universities accept UPI Study credits?
UPI Study has signed partner agreements with universities such as Thomas Edison State University, University of the People and Charter Oak State College, and works with universities such as Penn State, SNHU and SUNY. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities. Use "Find my college" on this page to check yours.
How long does Software Engineering take?
It is self-paced with no deadlines. The 103 lessons total about 11 hours of video; most students add reading and practice time and finish in a few weeks to a few months, on their own schedule.
How are the exams done?
Quizzes and assignments are online in the course. The final exam is taken online with proctoring; a person on the UPI Study team checks assignments, usually within two days.
How do my credits reach my college?
When the course shows 100% complete, request the official transcript from your dashboard. It is sent to the college you name, and you can send it to more than one. Check your college first with "Find my college" on this page, or ask Athena.

Ready for the full course? Earn 3 credits in Software Engineering.

103 video lessons, a quiz after each one, and the graded work that earns the credit. Recommended for credit by NCCRS.

Enroll in Software Engineering →Download the syllabusEvery course with PRO →
Software Engineering
3 credits · NCCRSEnroll →