skip to content

In BPMN 2.0, why is a lane labelled 'Background-check agency' not a participant, even though it names a separate organisation?

level: middleimportance: should knowfreq 35%

answer

  1. a label is not a party
  2. lanes live inside a lane set
  3. no process of its own
  4. who can the agency answer

basics

~20 s

In BPMN 2.0 a lane is only a partition of one process: it has no process of its own and is not a party to the collaboration. Naming it after the agency still makes the agency's work part of the employer's process.

solid answer

~50 s

A lane is defined inside a process's `laneSet`, and it only lists which of that process's flow nodes it partitions (`flowNodeRef`). It has no `processRef`, no participant identity and no separate token: everything in it is sequenced by the employer's process. A **participant** is declared in the `collaboration`, is drawn as a **pool**, and may reference its own process. So a lane labelled `Background-check agency` asserts that the employer's process performs and sequences the agency's steps, which is false for an independent organisation. It also leaves nothing for the exchange to attach to: communication with a separate party is drawn with message flows, which connect pools, and a lane cannot be the separate party in that exchange. The fix is to make the agency its own pool, white-box or black-box, and keep lanes for the employer's internal teams.

go deeper

for a junior

Recall that lanes sit inside one pool's process, while each independent party gets its own pool.

for a middle

Explain the metamodel difference: lanes live in a lane set of one process, participants live in the collaboration with an optional processRef.

for a senior

Spot models that bury outside parties in lanes, explain the control and accountability they misstate, and restructure them into pools.

for a principal

Decide where outsourced functions belong in a modelling standard, using control over sequencing as the test.

## What the model element actually is The confusion comes from the drawing: a lane and a pool are both labelled rectangles. The metamodel shows how different they are. | Aspect | **Lane** | **Participant (pool)** | |---|---|---| | Declared in | a `laneSet` owned by a **process** | the **collaboration** | | Identity | a partition, optionally tied to a `partitionElement` | a `PartnerEntity` and/or `PartnerRole` | | Own process | never | `processRef`, zero or one | | Contents | references to the process's flow nodes (`flowNodeRef`) | the whole process, if any | | Endpoint for another party's messages | no | yes, at its boundary or an element inside | | Execution semantics | none in the standard's execution chapter | its process runs its own instances | Clause 10.8 says lanes are used to **organise and categorise activities** within a pool, that their meaning is **up to the modeller**, and that BPMN does not specify their usage. The execution semantics chapter does not mention lanes at all. A lane is therefore a classification of the employer's own activities. ## What the agency lane claims Suppose the hiring model has one employer pool with lanes Recruiting, Hiring manager and Background-check agency, and a sequence flow goes from Recruiting's `Request check` to the agency lane's `Run check`, then on to the hiring manager's `Decide`. Read strictly, that model says: 1. `Run check` is an activity of the **employer's** process, started by the employer's token. 2. The employer controls when the agency starts and when it finishes. 3. There is no message: the request and the result are internal hand-offs. None of that matches reality. The agency receives a request, runs its own procedure on its own schedule, and returns a report. The employer's process can only **send** and **wait**. ## Why lanes cannot be the separate party - **No process of its own.** A lane cannot hold an independent process; its contents are part of the pool's process. - **Not in the collaboration.** A lane is not a participant, so it has no place in the collaboration's list of parties; it cannot be one end of an exchange between organisations. - **Wrong connector.** Communication between parties is drawn with message flows between pools; inside one pool everything is sequence flow. - **Wrong accountability.** The lane places the agency inside the employer's organisation chart, which misstates who is responsible for the check. ## The corrected model 1. Keep **Recruiting** and **Hiring manager** as lanes in the employer's pool; they are internal partitions. 2. Add a **Background-check agency** pool. If the agency's procedure is unknown or not yours to model, make it a **black box**. 3. Replace the internal hand-off with a send step in the employer's process, a message to the agency pool, and a receiving step that waits for the report. 4. Do the same for the **candidate**, who is also an independent participant. ## When a lane for an outside party is defensible Lanes are modeller-defined, so a lane named after an outsourced function is not illegal notation. It is defensible only when the outside party genuinely works **inside** your process: for example, contract recruiters who use your systems and follow your steps, and whose work you sequence. Then the lane describes a partition of your process by resource. The test is whether you control the sequence of their work; if you do not, they are a participant. ## A quick test for every lane Before accepting a lane in a review, ask three questions of it: 1. Does the pool's own process decide when this lane's work starts? 2. Is the work done under the same organisation's control and accountability? 3. Would anyone outside this process need to send it a message to get the work done? Two yeses and a no describe an internal lane. A no on the first two and a yes on the third describe a participant. The message flow rules confirm it: of the interaction nodes, only pools or participants, activities and events can be the source or target of a message flow, so a lane can never be the addressee. ## Common interview traps - Answering "because it is in another company" alone. The standard's reason is structural: a lane has no process and is not a participant. - Claiming lanes assign performers at run time. Performers are a resource assignment on activities; the lane's meaning is modeller-defined. - Forgetting that the candidate raises the same issue as the agency.

  • In BPMN 2.0, what is a lane set, and can one process have several?
    A lane set is the container for one or more lanes, owned by a process and not itself displayed. A process can contain one or more lane sets, and each lane set can partition the same flow nodes in a different way, for example by department in one and by system in another.
  • In BPMN 2.0, does putting a task in the Hiring manager lane make the hiring manager its performer?
    Not by itself. The standard leaves lane meaning to the modeller; performers are resource roles defined on the activity. A lane's partition element may reference a resource, but that is a classification a tool can use, not a separate performer assignment.
  • In BPMN 2.0, when is a lane named after an external firm acceptable?
    When the firm's staff work inside your process and you sequence their steps, as with embedded contract staff. If the firm runs its own procedure and only exchanges requests and results with you, it is a participant and needs its own pool.

saying these in an interview costs you the question

  • Believing a lane labelled with another company makes it a participant
  • Drawing a message flow between two lanes of one pool to show a hand-off
  • Assuming a lane has its own process instance and token
  • Thinking lane placement is the standard's performer assignment
  • Modelling an independent agency's steps as sequence-flow hand-offs