Diagram guides · Updated October 2026

Use case diagram online: who can do what, and the honest limits of drawing one

A use case diagram answers one question: who deals with this system, and what can each of them get out of it. The actors stand outside, the goals sit inside a boundary, and lines join each actor to the goals they can reach. This guide covers how to write a use case that is worth drawing, and how to build the diagram with a notation that has no use case type in it.

Read this first

Diagrams here come back as Mermaid, and Mermaid has no native use case diagram type. There are no stick figures, no true ovals and no UML boundary rectangle. What you can build is a deliberate approximation, and the rest of this page is how to build it well.

Open Flowchart Answers →Pick a different diagram type

One diagram per answer, so ask for one system at a time.

What a use case diagram is actually for

It is a scope document drawn as a picture. Before anyone argues about screens or tables, a use case diagram settles two things: which people and systems are outside the thing being built, and which goals the thing being built is responsible for satisfying. Everything inside the boundary is work you have signed up for; everything outside it is somebody else.

That is why it carries almost no detail. There is no order of events on it, no branching and no data. Those live elsewhere, which is the honest answer to why the diagram often feels thin: it is a contents page, not a chapter. Once the scope is agreed, the behaviour of a single use case is best drawn as a sequence diagram and the data behind it as an entity model.

The limitation, stated plainly

Mermaid supports a long list of diagram types, and the use case diagram is not among them. There is no keyword that produces stick figures and ovals, so no prompt will conjure one. This is a property of the notation rather than of the generator, and no amount of rewording gets around it.

What works instead is a left-to-right flowchart used as a stand-in, where each piece of the UML vocabulary is replaced by the nearest thing available:

Stick-figure actorA circle node, written with double brackets. It reads as an actor because of where it sits and what it is called, not because of its shape.
Oval use caseA stadium node, which is a rectangle with fully rounded ends. It is the closest shape available and it is close enough to be read correctly.
System boundary rectangleA subgraph wrapping the use cases, with the actors left outside it. The box has a title bar rather than a plain label, which is the visible difference.
Association lineA triple-dash open link, which draws without an arrowhead. This one is an exact match rather than a compromise.

Whether that is good enough depends entirely on how you are being marked. A module that grades strict UML notation will take points off for the shapes. A brief that wants the scope of a system communicated clearly will not care, and neither will a reader.

Building the approximation, line by line

Start with graph LR rather than the default top-down direction, because actors belong in a column on the left with their goals spreading out to the right. Declare the actors first, wrap the use cases in a subgraph, then join them with open links:

graph LR
  S((Student))
  T((Teacher))
  subgraph Gradebook
    U1([Submit work])
    U2([View grade])
    U3([Mark work])
  end
  S --- U1
  S --- U2
  T --- U3

Three choices in there are doing real work. The double brackets give a circle, which is as close to an actor symbol as the notation goes. The square-brackets-inside-round-brackets form gives a stadium shape, which reads as an oval at a glance. The triple dash draws a line with no arrowhead, which is exactly what a UML association is.

Keeping the actors outside the subgraph is not cosmetic. The boundary is the one piece of meaning this diagram exists to carry, so an actor accidentally declared inside the subgraph inverts the whole statement the sheet is making.

Writing use cases worth putting on the page

A use case is a goal with an outcome, phrased from the point of view of whoever wants it. Book a room is a use case. Room booking form is a screen, Validate dates is an internal step, and Database is not even in the right category. The quick test is whether the actor would be satisfied if that and only that happened.

Include and extend are the two relationships between use cases, and they are worth getting right because they are where marks are usually lost. Include covers behaviour that always happens as part of the larger goal; extend covers behaviour that only happens under some condition, and its arrow points the other way:

graph LR
  U1([Place order])
  U2([Take payment])
  U3([Apply coupon])
  U1 -.->|include| U2
  U3 -.->|extend| U1

Note that these two are drawn with arrows while the actor associations are not. That contrast is useful: an arrowhead on this diagram always means a relationship between two use cases, so a reader can tell the two kinds of line apart without reading any labels.

Prompting for it, then fixing the code

Ask Flowchart Answers for the approximation in the terms above rather than for a use case diagram, because that is what you are going to get either way and describing it precisely gets you a better first draft. A prompt such as: a graph LR where Student and Librarian are circle nodes on the left, and the use cases Search catalogue, Borrow book and Add title sit in a subgraph called Library.

Then correct it by hand. The Mermaid code appears next to the preview, it is editable, and the picture redraws as you type, so moving a use case into the subgraph or swapping an arrow for an open link takes one edit rather than a whole new request. One trap to know in advance: a label containing a bracket or a quote must itself be quoted. A node written as G[Sugar (food)] kills the parse, while G["Sugar (food)"] renders, and a single bad label takes down the entire diagram rather than one shape.

When it looks right, zoom the preview to check that no label has overlapped a line, then download the SVG. If you would rather have the finished picture narrated as part of a lesson, the visual lesson guide covers putting a diagram on a slide.

Four mistakes that turn it into a feature list

Use cases named as nounsLogin page is a screen, not a use case. Write the goal as a verb phrase from the point of view of the person with the goal: Log in, Reset password, Book a room.
Internal steps drawn as use casesValidate the form and Write to the database are things the system does to itself. They belong inside the description of a use case, not as ovals of their own.
Every actor joined to every use caseA sheet where all the lines cross is telling you the actors have not been distinguished. Draw only the associations that are actually true for that actor.
Include and extend used interchangeablyInclude is always, extend is sometimes, and the arrows point opposite ways. If you are unsure which applies, ask whether the base use case is still complete without it.

If the approximation will not pass and you need true UML notation, the honest answer is to draw it in a dedicated UML editor and use this tool for the parts of the assignment it does handle natively, which is most of them. The general drawing guide is a reasonable starting point for deciding what to draw where.

Use case diagram FAQ

Can this draw a real UML use case diagram?

Not literally. Mermaid, which is what the tool produces, has no use case diagram type, so there are no stick figures, no ovals and no proper UML system boundary available to it. What you can build is a close approximation with graph LR: actors as circles down the left, use cases as rounded shapes, plain lines between them, and a subgraph standing in for the boundary. For coursework that is marked on content it usually reads fine, and for coursework marked on notation it will not.

What counts as an actor?

Anyone or anything outside the system that starts an interaction with it or receives something from it. People are the obvious case, but a payment provider, a scheduled job or another system calling your API are all actors too. The test is whether it sits outside the boundary. A module inside your own system is never an actor, however active it is.

How do I show the system boundary?

Put every use case inside a Mermaid subgraph and leave the actors outside it. The subgraph draws a labelled box around its contents, which communicates the same thing as the UML boundary rectangle even though it is not the same notation. Name the subgraph after the system rather than after the project, since the boundary is meant to say what the software is responsible for.

What is the difference between include and extend?

Include means the behaviour always happens as part of the larger use case: placing an order always involves taking payment, so Place order includes Take payment. Extend means it sometimes happens under a condition: applying a coupon extends placing an order. The arrow directions are opposite, which is what most people get wrong. Include points from the base use case to the included one, while extend points from the optional one back at the base.

Is a use case the same as a user story?

No. A user story is one sentence about one need, written to be small enough to build in a sprint. A use case is a complete interaction from a trigger to an outcome of value, and it usually contains several stories worth of behaviour. On the diagram you are drawing use cases, so Book a room belongs there, while a story about a confirmation email does not get its own oval.

How many use cases should be on one diagram?

Few enough that someone can read the sheet and say what the system does. In practice that means the major interactions rather than every screen, and if you are past roughly a dozen you are listing features instead of describing a system. Split by actor or by subject area and draw more than one.

Why did my diagram come back as a top-down flowchart?

The generator leans towards graph TD when nothing says otherwise. For this approximation you want graph LR, because actors belong down the left-hand side with their use cases to the right. Ask for graph LR by name, or change the first line of the code once the draft appears, since the preview redraws from whatever is in the editor.

Can I download the use case diagram?

Yes, as SVG. Because it is a vector file you can scale it into a report without the actor labels going soft. There is no PNG, Visio or draw.io export, so if your submission requires one of those you will need to convert the SVG yourself.

Should the association lines have arrowheads?

In UML an association between an actor and a use case is a plain line with no arrowhead, because it records participation rather than direction. Mermaid gives you that with a triple-dash open link. Arrows belong only on the include and extend relationships between use cases, which is a useful visual signal that those two mean something different.

Tools: Flowchart Answers · Video Answers · Ask Questions

Draw a use case mapAsk about UML