PedroGeoGISdev wiki
  • Home
  • Linux OS
    • Linux: concepts
    • Linux: basic concepts
    • Linux: Bash
    • Linux: su and sudo
    • Linux: pipes
    • Linux: File System
    • Linux: Virtual Machines

    • Linux: distros
    • Linux Distros: Ubuntu
    • Linux Distros: Mint
    • Linux Distros: Debian
    • Linux Distros: openSuse
    • Linux Distros: Manjaro
    • Linux Distros: Red Hat Enterprise

    • Linux: laboratories
    • Linux Lab#LI01-1: Choose Linux
    • Linux Lab#LI01-2: Install at least three distributions
    • Linux Lab#LI01-3: Adjust user permissions
    • Linux Lab#LI02-1: Export env user with grep and pipe
    • Linux Lab#LI03-1: Manage users and groups
    • Linux Lab#LI03-2: Manage files
    • Linux Lab#LI03-3: Manage software
    • Linux Lab#LI03-4: Manage hardware
    • Linux Lab#LI04-1: Bash scripting, qtool
    • Linux Lab#LI04-2: Bash scripts as terminal tool
    • Linux Lab#LI04-3: Distribute the terminal app

    • Linux readings
    • Linux Resources
  • DevOps
    • What is DevOps
    • DevOps: Introduction
    • DevOps: Agile and Microservices
    • Infrastructure as code (IaC)
    • Immutable Infrastructure
    • Software Lifecycle

    • Documentation
    • How to document: Quarto and Obsidian

    • Network protocols
    • Network: Basics
    • Network: Client-server
    • Network Protocols
    • Network: DNS
    • Network: API Rest
    • Network: gRPC
    • Network: Websocket
    • Network: SMTP
    • Network: Ping
    • Network: UDP
    • Network: webhook
    • Network: SOAP
    • Network: graphQL

    • Version Control
    • Git
    • GitHub
    • Idea and GitHub 2023
    • Git and GitHub 2023 CLI

    • IDEs
    • IDE: Visual Code
    • IDE: IntellJIdea

    • DevOps tools
    • Amazon Web Services AWS
    • Docker
    • Jenkins pipelines
    • Kubernetes k8s
    • Digital Ocean
    • Nagios
    • Ansible

    • DevOps Laboratories
    • Lab 1: chat App
    • Lab 2: Spring Boot AWS AEB manually
    • Lab 3: Spring Boot and AWS S3 publisher
    • Lab 4: Spring Boot Docker/Jenkins
    • Lab 5: k8s on Digital Ocean
    • Lab 6: Spring Boot AWS codecommit

    • DevOps readings
    • DevOps Resources
  • MarkUp
    • MarkUp Languages
    • Introduction Markup
    • HTML Markup
    • Markdown Markup
    • Markdown and HTML working together, good idea?

    • Quarto Markdown
    • Quarto Markdown: basics
    • Quarto Markdown: creating
    • Quarto Markdown: publishing
    • Quarto Markdown: code & data
    • Quarto Markdown: api rest call
    • Quarto Markdown: OJS Cells
    • Quarto Markdown: cheat-sheet

    • Styling: CSS
    • Cascade Style Sheet
    • Cascade Style Sheet: Box Model and Containers
    • CSS: W3.css

    • MarkUp Languages Laboratories
    • Lab#MD01-1: Create and publish by Quarto

    • MarkUp Languages readings
    • MarkUp Languages Resources
  • Java SE
    • What is Java SE
    • Java Standard Edition: Basics
    • Java Standard Edition: Principles
    • Java MOOC Helsinki
    • Java MOOC Helsinki Syllabus

    • Java Create Project
    • Java SE: Maven
    • Java SE: Create Maven Project
    • Java SE: Project push GitHub
    • Java SE: JUnit and TDD

    • Java Concepts
    • Java SE: Class and Objects
    • Java SE: Scope
    • Java SE: static modifier
    • Java SE: Coupling and DDD
    • Java SE: Packages
    • Java SE: Abstract/Interface
    • Java SE: Java 8

    • Java Principles
    • Java SE: Encapsulation
    • Java SE: Abstraction
    • Java SE: Inherence
    • Java SE: Polymorphism

    • Java Design Patterns
    • Java Patterns: UML
    • Java Patterns: Types
    • Singleton
    • Factory
    • Abstract Factory
    • Builder
    • Facade
    • Bridge
    • Decorator
    • Composite
    • Observer
    • Strategy
    • State
    • Commander

    • Java SE Laboratories
    • Lab#SE00-1: Maven Person
    • Lab#SE00-2: Maven Clinic
    • Lab#SE00-3: Library Model
    • Lab#SE00-4: Abstract/Interface Human
    • Lab#SE01-1: Maven/Gradle Person and Account
    • Lab#SE01-2: Maven/Gradle Person and Account stored in JSON
    • Lab#SE02-1: Movie/Review, Model
    • Lab#SE02-2: Movie/Review, CRUD Operations
    • Lab#SE02-3: Movie/Review, factory
    • Lab#SE02-4: Movie/Review, interactivity and coupling
    • Lab#SE02-5: Movie/Review, simulate interactivity by console
    • Lab#SE03-1: Library/Book, Core-Model
    • Lab#SE03-2: Library/Book, Sprint Zero
    • Lab#SE03-3: Library/Book, Expand Model
    • Lab#SE04-1: healthyFood Restaurant, Core Model

    • Java SE readings
    • Java SE Resources
  • Python
    • Python Basics
    • Python: Basic Concepts
    • Python: Tips
  • JavaScript
    • JavaScript Basics
    • JavaScript: Basic Concepts
    • JavaScript: Tips
  • Spring
    • Spring Legacy
    • Spring Framework
    • Spring MVC
    • Springs Servlets

    • Spring Boot Basics
    • Spring Boot: fundamentals
    • Spring Boot: create a Project
    • Spring Boot: H2 DB and Thymeleaf
    • Spring Boot: cycle

    • Spring Boot Concepts
    • Spring Boot: Dependency Injection
    • Spring Boot: Annotations
    • Spring Boot: Controller
    • Spring Boot: View
    • Spring Boot: Thymeleaf
    • Spring Boot: Vaadin Flow
    • Spring Boot: Vaadin Hilla
    • Spring Boot: Model
    • Spring Boot: Rest
    • Spring Boot: Data & DB
    • Spring Boot: JPA & DI
    • Spring Boot: JPA Mappings
    • Spring Boot: JPA Relationships
    • Spring Boot: JPA Queries
    • Spring Boot: JPA Inherence
    • Spring Boot: Scaling

    • Spring Boot Laboratories
    • Lab#SB00-1: Library UML
    • Lab#SB00-2: CRUD User
    • Lab#SB00-3: LibraryManagement
    • Lab#SB00-4: API Rest
    • Lab#SB00-5: Rest & JPA-H2
    • Lab#SB00-6: Rest & MongoDB
    • Lab#SB00-7: Styling
    • Lab#SB01-1: DataBase
    • Lab#SB02-1: JPA Relationships
    • Lab#SB03-1: APIs & cloud
    • Lab#SB04-1: JPA Inherence
    • Lab#SB05-1: API Rest
    • Lab#SB06-1: employeeCourse
    • Lab#SB07-1: monitor Book
    • Lab#SB08-1: Restaurant UML
    • Lab#SB08-2: Vaadin
    • Lab#SB08-3: H2 and API Rest
    • Lab#SB08-4: JPA
    • Lab#SB08-5: Test API Rest
    • Lab#SB09-1: SpringIO Conference

    • Spring Boot readings
    • Spring Boot Resources
  • ReactJS
    • ReactJS: Principles
    • React JS: Introduction
    • React JS: render virtual DOM
    • React JS: Create a React project
    • React JS: Components
    • React JS: JSX
    • React JS: props and state

    • JavaScript: web scripting
    • JavaScript: basics
    • JavaScript: functions
    • JavaScript: objects
    • JavaScript: variables
    • JavaScript: flux control

    • ES6: ECMAScript 6
    • React JS ES6: arrow functions
    • React JS ES6: import modules
    • React JS ES6: array, data and key
    • React JS ES6: destructuring
    • React JS ES6: spread operator

    • ReacJS 18: Hooks
    • React JS: Rules of Hooks
    • ReactJS: useState
    • React JS: useReducer
    • React JS: useRef
    • React JS: useEffect
    • React JS: useContext
    • ReactJS: useMemo
    • ReactJS: custom hooks

    • ReactJS: Designing an App
    • React JS App: async
    • React JS App: events
    • React JS App: router
    • React JS App: conditional render
    • React JS App: styling

    • React JS: Laboratories
    • Lab#RE01-1: API Rest Axios
    • Lab#RE02-1: Router & Hooks
    • Lab#RE03-1: to-do app
    • Lab#RE03-2: HighCharts
    • Lab#RE03-3: API Rest Mono
    • Lab#RE03-4: API Rest Domains
    • Lab#RE03-5: data management
    • Lab#RE04-1: todo & server
    • Lab#RE04-2: Spring Boot & ReactJS
    • Lab#RE05-1: chat & websockets
    • Lab#RE05-2: chat: backend
    • Lab#RE05-3: chat & AWS
    • Lab#RE05-4: chat: test ws AWS
    • Lab#RE05-5: chat & front
    • Lab#RE05-6: chat & ws: front
    • Lab#RE06-1: healthyFood Restaurant
    • Lab#RE06-1-PR: create a pull request
    • Lab#RE07-1: traffic lights simulation

    • React JS readings
    • ReactJS Resources
  • Learning
    • Vocabulary
    • General Vocabulary
    • SCRUM Vocabulary
    • DevOps Vocabulary
    • Java SE Vocabulay
    • Spring Boot Vocabulary
    • DataBase Vocabulary
    • ReactJS Vocabulary
    • Web Vocabulary

    • Learning
    • Useful Questions
    • Learning: tips
    • Writing
    • Taking Notes
    • Comments
    • Document
    • Auto-Evaluate

    • Books & Articles
    • Books
    • Articles

    • What is SCRUM
    • SCRUM Agile Methodology
    • Agile Manifesto & Values
    • SCRUM Guide

    • Scrum Steps
    • Meetings, Impediments and Iterations
    • User stories, Tasks and Habits
    • Delivering Value & Communication
    • ScrumMaster, how it works
    • Mindset, the key to everything
    • Product Owner, how it works
    • Managing Time & Mind
    • Team & the Specialist
    • Albertus’ Dilemma
    • Before SCRUM
    • Team Dynamics
    • Emotions and Thoughts
    • Decision Making and Intuition
    • Beyond SCRUM
    • Balances, atmosphere and tools

    • Resources
    • SCRUM Resources
  • QGIS
    • QGIS basics
    • QGIS: basic concepts

    • QGIS laboratories
    • QGIS Laboratory 1: Introduction to Open Source GIS
  • ArcGIS Pro
    • ArcGIS Pro basics
    • ArcGIS Pro: basic concepts

    • ArcGIS Pro laboratories
    • ArcGIS Pro Laboratory 1: Getting Started
  • Bookmarks
    • Online Resources
    • Online Resources
  • About
    • About me and this site
    • About me
    • About this site
    • About images credit
  • Email
  • GitHub
  • LinkedIn
  1. Scrum Steps
  2. Before SCRUM
  • Vocabulary
    • General Vocabulary
    • SCRUM Vocabulary
    • DevOps Vocabulary
    • Java SE Vocabulay
    • Spring Boot Vocabulary
    • DataBase Vocabulary
    • ReactJS Vocabulary
    • Web Vocabulary

  • Learning
    • Useful Questions
    • Learning: tips
    • Writing
    • Taking Notes
    • Comments
    • Document
    • Auto-Evaluate

  • Books & Articles
    • Books
    • Articles

  • What is SCRUM
    • SCRUM Agile Methodology
    • Agile Manifesto & Values
    • SCRUM Guide

  • Scrum Steps
    • Meetings, Impediments and Iterations
    • User stories, Tasks and Habits
    • Delivering Value & Communication
    • ScrumMaster, how it works
    • Mindset, the key to everything
    • Product Owner, how it works
    • Managing Time & Mind
    • Team & the Specialist
    • Albertus’ Dilemma
    • Before SCRUM
    • Team Dynamics
    • Emotions and Thoughts
    • Decision Making and Intuition
    • Beyond SCRUM
    • Balances, atmosphere and tools

  • Resources
    • SCRUM Resources

On this page

  • 1 Agile and Managment history
    • 1.1 Agile and Managment 1945-2000
  • 2 Agile milestones
  • 3 Toyota SCRUM
    • 3.1 Taiichi Ohno
  • 4 SCRUM experiences
    • 4.1 Why Do Managers Hate Agile?
    • 4.2 Banc de Sabadell & British bank TSB
    • 4.3 Delta and Northwest merger
    • 4.4 How Cisco IT Uses Agile Development
    • 4.5 Microsoft
  • 5 References
  • Edit this page
  • Report an issue
  1. Scrum Steps
  2. Before SCRUM

Before SCRUM

SCRUM Step 10

scrum
before-scrum
Before SCRUM, software development primarily followed methodologies like Waterfall, V-Model
Author

albertprofe

Published

Tuesday, June 1, 2021

Modified

Sunday, August 10, 2025

📘 Summary: SCRUM Step 10 - Before SCRUM

Before SCRUM, software development primarily followed methodologies like Waterfall, V-Model, Incremental Model, and Spiral Model, which had their advantages but lacked flexibility and early adaptability.

The Project Management Office (PMO) provided organizational standards.

Agile principles evolved from Toyota’s manufacturing principles, Lean Manufacturing, Crystal Clear, and Refactoring. In the 1990s, Jeff Sutherland and Ken Schwaber independently developed SCRUM, formalizing roles and events.

The Agile Manifesto in 2001 marked a pivotal moment. SCRUM’s integration with Toyota Production System at Toyota Connected exemplifies its effectiveness in Lean Production. Embracing SCRUM requires understanding complexity, teamwork, and continual improvement. Agile isn’t a goal; it’s an outcome.


Keywords: SCRUM Step 10 - Before SCRUM

Waterfall Model, V-Model, Incremental Model, Spiral Model, Project Management Office (PMO), Agile Principles, Toyota Production System (TPS), Lean Manufacturing, Crystal Clear, Refactoring, Toyota Connected, Lean Production, Taiichi Ohno.



1 Agile and Managment history

1.1 Agile and Managment 1945-2000

Before SCRUM, software development primarily followed methodologies like Waterfall, V-Model, Incremental Model, and Spiral Model:

Methodology Description Characteristics Advantages Disadvantages Year Created Decades Most Used
Waterfall Model Linear and sequential approach to software development. Sequential phases: requirements, design, implementation, testing, deployment, and maintenance. Easy to understand, well-suited for small projects. Lack of flexibility, late detection of errors. 1950s 1960s-1980s
V-Model Extension of the Waterfall model emphasizing verification and validation at each stage. Testing phase corresponds to each development stage, forming a V-shape. Early detection of issues, specific deliverables. Similar inflexibility as the Waterfall model. 1980s 1990s-2000s
Incremental Model Divides system functionality into small, manageable modules or increments. Each increment builds on the functionality of the previous one, with the final product formed by integrating all increments. Partial implementation, early delivery, easier testing. Requires careful planning, potential integration issues. 1970s 1980s-1990s
Spiral Model Combines iterative development with aspects of the Waterfall model, incorporating risk assessment and mitigation. Involves cycles with planning, risk analysis, engineering, testing, and evaluation. Better risk management, accommodates changes. Complex, extensive documentation, not suitable for small projects. 1988 1990s-2000s
PMO (Project Management Office) Organizational structure defining and maintaining project management standards and practices. Provides governance, establishes best practices, ensures alignment with business goals, and offers support to project managers. Standardization, support, alignment with goals. May not directly manage projects, requires proper implementation. 20th Century 1990s-Present

2 Agile milestones

Agile history from Toyota, Crystal, Refactorin to SCRUM

Agile history from Toyota, Crystal, Refactorin to SCRUM

From Toyota’s manufacturing principles to the Agile Manifesto and Scrum, agile methodologies have continually adapted, fostering collaboration, adaptability, and customer-centricity in software development processes.

Agile methodologies have evolved over decades, with roots tracing back to post-World War II Japan. In 1945, Toyota implemented concepts influenced by W. Edwards Deming’s Total Quality Management, shaping the Toyota Production System (TPS). TPS emphasized continuous improvement, flexibility, and customer value.

In the 1980s, Toyota engineer Taiichi Ohno introduced Lean Manufacturing, influencing agile practices by emphasizing efficiency and eliminating waste.

Crystal Clear, an agile methodology developed by Alistair Cockburn in the 1990s, emphasized communication and teamwork. Concurrently, Martin Fowler’s “Refactoring” book highlighted iterative code improvement.

In the 1990s and early 2000s, Jeff Sutherland and Ken Schwaber independently developed Scrum. Rooted in empirical process control theory, Scrum formalized roles (Scrum Master, Product Owner, and Development Team) and events (Sprints) to enhance software development agility.

The software development industry began adopting agile principles in the 1990s. A seminal moment was the publication of the Agile Manifesto in 2001, where software developers articulated values such as individuals and interactions over processes and tools.

3 Toyota SCRUM

Toyota Connected uses Scrum combined with the Toyota Production System to deliver Lean Production, enabling teams to deliver rapid PDCA cycles. Scrum of Scrums, Meta Scrum, and the chief product owner, are some of the approaches used to scale Scrum for multiple teams and products. Agility is not the goal. It’s a result, an outcome.

Note
  • There is no one-size-fits-all approach to being agile, or to scaling Scrum
  • Lean and Agile are different things, but are great partners
  • You can be lean without being agile, and you can be agile without being lean
  • Executives must be fully engaged and part of the process
  • Understanding complexity and multi-team systems is critical for success

3.1 Taiichi Ohno

Taiichi Ohno

Taiichi Ohno

Taiichi Ohno philosophy:

  • You are a cost >>> First reduce waste.
  • First say, “I can do it.” >>> And try before everything.
  • The workplace is a teacher >>> You can find answers only in the workplace.
  • Do anything immediately >>> Starting something right now is the only way to win.
  • Once you start something, persevere with it >>> Do not give up until you finish it.
  • Explain difficult things in an easy-to-understand manner >>> Repeat things that are easy to understand.
  • Waste is hidden. Do not hide it >>> Make problems visible.
  • Valueless motions are equal to shortening one’s life.
  • Re-improve what was improved for further improvement.
  • Wisdom is given equally to everybody. The point is whether one can exercise it.

4 SCRUM experiences

4.1 Why Do Managers Hate Agile?

  • Why Do Managers Hate Agile?

Why don’t Agile and management get along? In a poll last Wednesday of some 400 people working in many different firms where the practices known as Agile and Scrum are being implemented,

88% reported tension between the way Agile/Scrum teams are managed in their organization and the way the rest of the organization is managed.

Only 8% reported “no tension.”

The vertical world of hierachical bureaucracy

The vertical world of hierachical bureaucracy

As Gary Hamel has noted, hierarchical bureaucracy solved two essential problems:

  • getting semiskilled employees to perform repetitive activities competently and efficiently;
  • coordinating those efforts so that products could be produced in large quantities.

In a stable environment, these liabilities didn’t matter much.

Change wasn’t important. (…) With semi-skilled employees performing repetitive tasks, collaboration wasn’t important. And who really cared if the workers were dispirited? It was enough that they had their job and their paycheck.

Then the world became turbulent

But the world changed and the marketplace became turbulent. There were a number of factors: Globalization, deregulation, and new technology, particularly the Internet. The Internet changed everything.

The answer was, collaboration, teamwork, Agile.

The horizontal world of Agile

The horizontal world of Agile

4.2 Banc de Sabadell & British bank TSB

What broke the bank

4.3 Delta and Northwest merger

How to Merge Two Airlines

4.4 How Cisco IT Uses Agile Development

How Cisco IT Uses Agile Development with Distributed Teams and Complex Projects

4.5 Microsoft

  • Surprise: Microsoft Is Agile
  • Microsoft’s 16 Keys To Being Agile At Scale
  • What is Scrum?
  • Azure Boards

5 References

  • SCRUM: Step 3
  • A Brief History of Scrum (Time)
  • Toyota Mejora continua
  • 10 companies killing it at scaling agile
Back to top
Albertus’ Dilemma
Team Dynamics

This website is built with Quarto.

Difficulties are just things to overcome, after all. Ernest Shackleton

  • Edit this page
  • Report an issue