Development Basics

What Is Software Modeling and Why Use It?

What Is Software Modeling and Why Use It?

The ISO edition of the UML 2 specification alone runs 740 pages (ISO/IEC 19505-2:2012). The models people draw with it are usually tiny, because a model only needs to cover whatever the team is arguing about that week.

Teams that do software modeling draw a system’s structure, behavior and requirements as abstract models, then use them to analyze and validate the design before and during implementation. Developers, architects and testers all do it, and UML is only one of the notations they pick from.

What Software Modeling Is, and What It Is Not

SWEBOK, the IEEE Computer Society’s body of knowledge, describes the activity as capturing only the parts of the software that matter for the decision in front of the team.

That selectivity is the whole value. A model of a software system is useful mostly because it leaves things out.

People mix it up with a few neighboring things. It isn’t a development process, since choosing waterfall or agile organizes the work while modeling describes what is being built. It isn’t a diagram either, because one diagram shows a single viewpoint of the model. UML is the best-known language, but SysML, BPMN, ER notation and the C4 model also describe parts of a software project. And simulation or 3D modeling software belongs somewhere else entirely, since those tools model physical or numerical systems, not software design.

Waterfall, iterative and agile are lifecycle models for organizing a project, and modeling sits inside whichever one a team picks.

Why Do Teams Model Software Before Coding?

Return on modeling before code is written

Mostly to catch design mistakes before they reach code.

A single picture that developers and non-technical readers can both check gets everyone looking at the same thing, and it forces stakeholder needs into a form someone can review. Structure and behavior can be tested against the requirements on paper first. Later the same model works as a reference for people who join the team, and in model-driven setups the tools generate code skeletons from it.

Kept next to the code, a model doubles as software documentation that a new contributor can read before opening the first file.

Ho-Quang and colleagues surveyed 485 contributors across 458 open source projects (ICSE 2017), and collaboration came out as the main reason people used UML. The models also help newcomers, including people who never draw any themselves.

The evidence on defects is thinner. A 2019 Mining Software Repositories study compared 50 GitHub projects that use UML with 93 that do not, and the UML group showed a small but statistically significant lower defect proneness.

That is an association in observational data. It doesn’t prove that diagrams cause fewer bugs.

Where models really pay off is when more than one person has to understand the design.

Types of Software Models

YouTube player

Models get sorted in two ways. One is by what they describe, where structural and behavioral models are the two UML families and interaction models sit awkwardly between them. The other is by abstraction level, which separates conceptual, logical and physical models.

Structural, behavioral and interaction models

UML 2.5 defines 14 standard diagram types, split between a structural family and a behavioral one (IEEE TechNav, as of UML 2.5.1, the current OMG specification). Older course material written for UML 2.0 counts 13 (slides from the University of Colorado are one example), so the number you see depends on which version the author had in front of them.

Class, component, deployment and package diagrams are the structural ones, showing what the system is made of. Behavior, meaning what the system does over time, gets use case, activity and state machine diagrams. Then there’s interaction: sequence, communication and timing diagrams, which show how parts exchange messages.

Strictly speaking, UML files interaction diagrams under behavior. I’d treat them as their own group, since they answer a different question, namely who talks to whom and in what order.

Component and deployment diagrams record decisions that belong to software architecture, while a sequence diagram checks one scenario message by message.

Conceptual, logical and physical levels

Abstraction level decides how much technology a model admits.

A conceptual model names business concepts and the relationships between them, with no technology in it at all. Logical models add attributes, keys and rules but still don’t care which database or platform sits underneath. Physical models are the ones tied to a chosen database or platform, down to tables, data types and indexes.

Early design talks stay conceptual. Physical models belong to whoever builds the schema or the service.

Modeling Languages and Notations Compared

YouTube player

No single notation covers everything, so the choice follows the part of the system being described.

LanguageAspect modeledOrigin or maintainerBest fit
UMLSoftware structure and behaviorOMG, ISO/IEC 19505Object-oriented design
SysMLSystems, requirements, parametricsOMG, v2 adopted 2025Hardware plus software
BPMNBusiness processesOMG, ISO/IEC 19510Workflow specification
ER notationData entities and relationshipsPeter Chen, 1976Database design
C4 modelArchitecture in four levelsSimon BrownArchitecture docs for mixed audiences

On the standards side, ISO/IEC 19505-2:2012 defines UML 2, and ISO confirmed that edition again in 2025. UML 2.5.1 is the current OMG specification as of October 2026. BPMN 2.0.1 is published as ISO/IEC 19510:2013, and the ISO text is identical to the OMG version.

SysML moved more recently. OMG approved final adoption of SysML v2 in July 2025, and the release pairs a textual notation with the graphical one.

C4 is the odd one out. The official site by Simon Brown defines four hierarchical diagrams (system context, containers, components, code) and states that the model is notation independent and tooling independent.

UML may be the default name in the field, but Marian Petre interviewed 50 professional engineers in 50 companies and 35 of them used no UML at all (ICSE 2013). The others used it selectively, as a way to think things through.

If the question is about database schema or a business workflow, UML is the wrong place to start. ER notation and BPMN were built for those.

Where Software Modeling Fits in the Development Life Cycle

Modeling doesn’t belong to one phase. It runs from requirements through design, implementation and maintenance, and what gets drawn changes along the way. In requirements work, use case and activity models turn stakeholder needs into something people can review. Design is where class, component and sequence models fix structure and message flow. During implementation, models either feed code generation or sit next to the developers as a blueprint. In maintenance, reverse-engineered diagrams explain existing code before anyone changes it.

At the front of the cycle, requirements engineering supplies the input, and the models give reviewers something concrete to challenge before anyone writes code.

Martin Fowler’s classification, published 28 May 2003, sorts UML use into sketch, blueprint and programming language modes. In UML Distilled he calls sketching by far the most common.

Forward engineering means the diagram comes first and the code follows. Reverse engineering goes the other way, rebuilding a diagram from existing code so someone can understand it.

Hebig and colleagues scanned 10 percent of all GitHub projects (1.24 million) and found 21,316 UML diagrams in 3,295 projects. Creating or updating models happened most often in a short phase at the project start (MODELS 2016).

That shows when models get drawn, not whether they stay accurate.

Once software reaches post-deployment maintenance, reverse engineering rebuilds diagrams from code. Round-trip tools try to keep model and code in sync in both directions, and how well that works depends on the tool.

How to Create a Software Model, Step by Step

Start with the question the model has to answer. Everything else follows from that.

  1. Write the question down in one sentence, such as “What happens when a payment fails?” A model without a question collects detail nobody asked for.
  2. Decide who will read it. Developers need classes and messages, while stakeholders need context and flow.
  3. Pick the view and the notation. Behavior questions point to sequence or activity diagrams, structure questions to class or component diagrams, and schema questions to ER notation.
  4. Set the abstraction level. Stay conceptual to agree on scope, go logical for design, and only reach for physical when someone is building the schema or service.
  5. Draw it, then walk the diagram through with someone who did not draw it and write down every assumption that came up.
  6. Give it an owner. Someone updates the model when the design changes, or the diagram carries a date and a snapshot label.

Take a checkout flow. The question is what happens when the payment provider times out, the readers are backend developers and QA, and a logical-level sequence diagram fits. You stop when every failure path has a defined response.

The owner is usually a tech lead or software architect, because the person who changes the design is the person best placed to keep the model true.

A model with no owner is a snapshot, and it should be labeled as one.

Choosing Between Model-Driven, Agile and Sketch-Level Modeling

Most teams should start small. Sketch-level modeling covers design discussion and agile modeling suits short iterations, while model-driven engineering only makes sense when generated code or several target platforms justify the upfront cost.

ApproachChoose it whenIt breaks when
Sketch-levelThe design is open and the audience is in the roomOther people need the result later
Agile modelingIterations are short and requirements shiftNobody owns updates
Model-driven engineeringGenerated code or multiple platforms repay the setupTooling and training cost more than they save

A decent rule of thumb is to model no more than the team can maintain, unless the model is a one-shot and throwaway. Bizzdesign’s guidance on architecture models in agile teams states it that way.

Applying it takes two questions. Who reads the model, and who updates it? Then ask how long it needs to live.

Model-driven engineering and Model-Driven Architecture

According to a research roadmap on model-driven development of complex software, the OMG launched Model-Driven Architecture (MDA) in 2001 as a framework of model-driven engineering standards. MDA looks at a system through the computation independent model (CIM), which states requirements and domain concepts in business vocabulary. Next comes the platform independent model (PIM), the design without hosting-platform details, and after that the platform specific model (PSM), which is the same design with one platform’s details added.

Model transformation moves a PIM toward one or more PSMs. Lecture notes from San Jose State University describe the end goal as compiling models into code for a specific platform.

Practice stops short of that goal. A survey of 450 practitioners plus 22 interviews found developers rarely generate whole systems and apply model-driven engineering to key parts instead (Whittle, Hutchinson and Rouncefield, IEEE Software, 2014).

Agile modeling

Scott Ambler’s Agile Modeling method asks for artifacts that are just barely good enough (JBGE), meaning sufficient for the task at hand and no more. How much modeling does that add up to? Usually less than teams expect.

JBGE is situational and changes over time. An artifact that stops being good enough needs an update, and one that is more than good enough is a sign to stop polishing.

The approach suits teams that already work in short iterations through agile development, where requirements shift between sprints.

Sketch-level modeling

A whiteboard session that ends when the conversation does counts as sketch-level modeling. The drawing is disposable, which is why it costs almost nothing.

Photograph the result if a decision came out of it. Anything others will consult later gets redrawn as a maintained diagram.

Software Modeling Tools by Job and Cost

YouTube player

Full modeling environments are built for UML and SysML repositories with code generation. Text-based tools suit diagrams that live next to code, and a general diagramming app handles quick drawings.

ToolNotationsCost modelBest job
Enterprise ArchitectUML, SysML, more via plug-insCommercial licenceUML and systems models at scale
Visual ParadigmUML, SysML, BPMN, ERCommercial licenceMixed notations in one suite
PapyrusUML 2, SysML, MARTEFree, EPL 2.0UML profiles and DSLs in Eclipse
PlantUMLText-based UML and other diagramsFree, several licensesDiagrams kept as text with code
MermaidText-based flow, sequence, class, ERFree, MITDiagrams inside Markdown docs
draw.ioGeneral-purpose diagramsFree, Apache 2.0 sourceQuick drawings, no licence cost
StructurizrC4 model via a text DSLLite free, paid hosted plansC4 diagrams from one model

Visual Paradigm lists single-seat licenses at US$1,999 (Enterprise), US$799 (Professional), US$349 (Standard) and US$99 (Modeler), per its 19 January 2026 release notice. The European Sparx Systems price list (sparxsystems.eu) shows Enterprise Architect named-user licenses from EUR 225 (Professional) to EUR 679 (Ultimate), checked October 2026.

GitHub has rendered Mermaid code blocks in Markdown since 14 February 2022. PlantUML is offered under several licenses, and the user picks the one that fits.

Text-based tools store diagrams as plain text, so source control shows exactly what changed in a diagram. Structurizr’s own documentation recommends that workflow for its DSL files.

It also names a limit. The browser-based DSL editor does not expose the full feature set, so Structurizr Lite or the command-line tool is the safer route.

Most teams don’t need a commercial suite. Mermaid and PlantUML carry no licence fee, and neither does draw.io, so sequence, class and flow diagrams are covered for free. I’d start there.

Paying for a commercial environment makes sense for SysML support or a shared model repository, or when code gets generated from UML.

When Software Modeling Stops Paying Off

Once a model costs more to maintain than it saves in understanding, it has become a liability.

Model drift

The code keeps changing and the diagram doesn’t. That gap is model drift. University of Cape Town MSc-IT notes (2011 edition) say iterative and agile methods accept this, since models and code stop matching once both change.

A diagram supports maintainability only while it matches the code. A stale one misleads precisely because readers trust it.

Structural diagrams go stale after code refactoring, which changes structure while behavior stays the same.

Date every diagram and label it snapshot or maintained.

Maintenance cost and over-modeling

A 2022 arXiv study of requirements models in very-large-scale agile systems engineering looked at one Ericsson department, combining a survey of 33 engineers with five follow-up interviews. Engineers valued the models but were pragmatic about upkeep, since models go stale without enough people to correct them.

The concerns in the paper will sound familiar. Styles varied from author to author because nobody shared a way of modeling, and people hesitated to modify a model someone else had created. Some teams dropped models altogether.

Tooling adds its own cost. Liebel and colleagues surveyed 112 mostly professional model-based engineering users in embedded systems (2014) and found the main shortcomings were interoperability difficulties between tools and high training effort for developers, along with plain usability issues.

Cases where formal models do not apply

Skip the formal model for a one-shot script or an exploratory prototype. Same for a small team that already knows its code base well.

There, a short README or a photographed whiteboard answers the question at a fraction of the cost.

Model-driven engineering fails for a different reason. Hutchinson, Whittle and Rouncefield (Science of Computer Programming, 2014) combined a large online survey with case studies of four commercial organizations adopting it, and found that organizational and managerial factors, along with social ones, decided the outcome more than technical ones.

Three of the four organizations described genuine success. What they needed was a progressive, iterative rollout and visible organizational commitment, plus integration with existing processes and a clear business focus.

Software Modeling FAQ

Who created UML, and who maintains it?

UML came out of Rational Software, where Grady Booch, Ivar Jacobson and James Rumbaugh merged their separate methods into one.

The Object Management Group adopted it in 1997 and still maintains the specification (IEEE TechNav).

How does software modeling differ from data modeling and business process modeling?

Software modeling looks at the whole system, structure and behavior both. Data modeling is narrower and only cares how information is stored and related, while business process modeling follows work as it moves between people and systems.

The three overlap. An ER diagram feeds the database design, and a BPMN process often supplies the requirements that a UML model then refines.

What is a metamodel, and how does it relate to a domain-specific language?

The official UML specification is itself given as a metamodel, which means a model that defines the concepts and rules a modeling language uses.

A domain-specific language narrows a notation to one field, and UML profiles are one way to build such a language (Eclipse Papyrus documentation).

How does domain-driven design relate to software modeling?

It shares the goal of modeling but puts the business domain in the middle.

Eric Evans introduced domain-driven design to keep a model of the domain aligned with the code. UML is a language, not a methodology, so teams can use it to draw that model.

Can a team learn software modeling without learning all of UML?

Yes. Start with one question and one diagram, such as a sequence diagram of a feature about to be built, then add class or component diagrams when a question calls for them.

Text-based tools like Mermaid and PlantUML make practice cheap.

The Recurring Cost of Software Modeling

The drawing session is the cheap part. What a model really costs is a review at every release, and that upkeep decides whether anyone can still trust it.

Budget the upkeep before the first drawing, because drawing is front-loaded in practice and abandonment happens during maintenance.

Put a model review inside each release. In that review, keep only the diagrams that still answer a live question and retire the ones whose question is gone.

The price of this discipline is fewer diagrams and coarser detail, in exchange for models readers can trust.

Record the surviving models in a design document that carries a review date.

Bogdan Sandu

Stay sharp. Ship better code.

Every week: one curated article, one tool worth knowing, one tip you can use tomorrow. No noise, no padding.