Mapping software flow with Celean’s prototype methods
Software delivery is frequently explained through ceremonies, tools and output: stand-ups, sprint boards, code repositories and releases. Those elements reveal activity, but they can conceal the real movement of work. A ticket may wait for analysis, sit behind a merge queue, return from testing with unclear ownership, or trigger another ticket without anyone seeing the full chain. Mapping flow makes those delays visible.
A useful software value-stream map follows a unit of customer value rather than a sequence of departments. It records how a request becomes an increment, where decisions are made, which handoffs create queues, and how quickly feedback reaches people who can act. The map then becomes a design object: teams can test alternative policies, service arrangements or system integrations before committing to a full digital change.
Project Visit presents research into digital visual planning, Kanban, enterprise systems and lean processes through practical collaboration. Its prototype-oriented methods are particularly relevant to software development, where requirements change, technical work is partly invisible and conventional process diagrams rarely reflect day-to-day reality. The approach combines observation, visual modelling and iterative testing to create a shared understanding of how work actually flows.
Why software flow needs more than a backlog
A backlog shows intended priorities, while a flow map reveals the conditions under which those priorities become usable software. The distinction matters because a team can have a well-ordered backlog and still experience long waits between product decisions, architecture review, development, testing and release. Code-related delays also affect flow: pull requests may accumulate, environments may be unavailable, and defects may remain without a clear owner.
Current-state mapping should distinguish value-adding activities from waiting, rework and unnecessary coordination. In a software context, that can include customer clarification, acceptance criteria, dependency coordination, coding, automated testing, security checks, approval and operational handover. A visual representation makes queues and feedback loops easier to discuss than a process document or list of team responsibilities. It also creates a neutral artefact for people who interpret the same delay differently.
A prototype turns that representation into something that can be challenged. Instead of debating an abstract future process, participants can move cards, trigger notifications, change work-in-progress limits and observe the consequences of a policy. The prototype need not reproduce every feature of an enterprise system. Its value lies in making assumptions about demand, capacity, handoffs and information flow tangible enough to test.
For context, the Celean research team documents the collaboration between Chalmers University and industry partners. This research setting is important because prototype methods connect conceptual lean thinking with artefacts used in real work. The resulting map can inform improvement while remaining honest about the limitations of the data and operating environment.
Turning the current state into a testable visual system
The starting point is a short period of observation rather than an idealised account of the process. Teams can examine recent work items, board changes, service requests and deployment records to identify what happened between formal status updates. This often exposes the gap between the official workflow and the informal coordination that keeps it moving. Experienced staff may resolve an ageing ticket through a direct conversation, while newer team members wait without knowing whom to ask.
The map should then become a shared visual work system. Cards or work items move through lanes that represent meaningful stages, and each lane has an explicit entry condition, exit condition and responsible role. Kanban policies can clarify which work may start, when downstream teams pull new items and where work-in-progress limits apply. Visual project management then provides more than visibility: it supports coordination around a common operating policy.
A useful prototype may progress from paper-based cards to a clickable interface and finally to a tool connected with selected enterprise-system data. Each stage answers a different question. Paper reveals sequence and queue size; a clickable prototype tests usability and policy; an integrated version tests whether information can flow reliably between systems. Moving between these levels prevents the team from investing in automation before the underlying workflow is understood.
The visual map should also show exceptions rather than hiding them beneath a single average. Urgent production incidents, regulatory approvals, dependencies on another team and exploratory spikes may follow different routes. Recording these variations helps the team estimate lead time honestly and identify whether a delay comes from a necessary constraint, an ambiguous policy or repeated rework.
Connecting visual planning with enterprise systems
Software work rarely begins or ends on a Kanban board. A request may originate in a customer relationship system, pass through issue tracking, move into version control and continuous integration, then enter a service desk after release. Enterprise systems hold useful evidence, but fragmented statuses can make the end-to-end journey difficult to reconstruct. Visual planning becomes valuable when it connects these organisational and technical boundaries without forcing every team into the same tool.
A low-fidelity prototype can define the essential links first. For example, an approved customer request might create a delivery item, a completed deployment might update the service record, and a production incident might return to the product backlog. Analysts can test whether identifiers remain consistent, whether status changes occur at the right moment and whether people can trace an item without consulting several administrators. This avoids premature commitment to a particular integration design.
As the prototype becomes operational, automated updates can reduce manual board administration. Events from issue tracking, repositories, test pipelines and deployment platforms can trigger visible state changes. Manual cards remain valuable where judgement is involved, especially during discovery, exception handling and risk review. The goal is not maximal automation; it is a trustworthy flow model in which the board reflects relevant work rather than becoming a second, disconnected reporting layer.
Measures should follow the mapped stages. Lead time measures the full journey from request to customer value, while cycle time focuses on active processing. Throughput shows how many items complete in a period, and blocked time identifies where work waits. These measures should be interpreted together and segmented carefully. A rise in throughput caused by rushing urgent items may conceal longer queues elsewhere, just as a short average can be distorted by a few very old tickets.
Adapting the method to Australian work contexts
Australian teams frequently combine offices, remote workers and operational sites. Engineers in Sydney and Melbourne may support systems used in Brisbane and Perth, while delivery schedules cross the eastern states and Western Australia. A handoff that seems same-day in Brisbane can lose a working day in Perth because of the time difference. Mapping must therefore include support windows, response expectations and the periods when a ticket can realistically be progressed.
Sector context also shapes the flow. Canberra public-sector agencies work within formal approval and procurement environments, while Sydney and Melbourne host substantial banking, insurance and technology operations associated with the wider Australian market. Resource and engineering organisations connect Brisbane and Perth with national and international supply chains. Teams using established platforms such as Jira and Confluence have strong local familiarity with digital work, but those systems still need to fit actual decision rights and compliance requirements.
Local team customs matter as much as technical infrastructure. Written handovers, after-hours support, informal escalation through a chat channel and reliance on a few experienced coordinators may all influence lead time. These customs are not automatically obstacles; they are signals of how the system currently works. A prototype can test a clearer policy without assuming that existing informal behaviour should disappear. A product-level ElvisFrog Trueways review also provides a useful reminder that usability and fit should be judged by work in context, not by feature counts alone.
Adaptation should preserve the purpose of the method while changing its details. Compliance checkpoints, leave coverage and regional release windows belong on the map where they affect flow. Co-design sessions should include developers, testers, product owners, operations staff and service-desk personnel, because each group sees a different portion of the journey. The visual artefact becomes locally credible when participants recognise their own constraints in it.
Recommendations for a credible flow-mapping trial
A small but complete trial is more informative than an enterprise-wide diagram created without operational evidence. The following recommendations help teams establish a reliable foundation for mapping and redesign:
- Choose a bounded value stream that delivers customer-visible value, such as one service change from intake to production, and record its boundaries before drawing any lanes.
- Capture recent actual work using completed items, board histories and interviews, then mark waiting time separately from active processing so delays become measurable.
- Build the smallest faithful prototype that reflects current roles, policies and information needs, adding integrations only after participants have validated the basic workflow.
- Make flow policies explicit by defining pull conditions, ownership, work-in-progress limits and exception routes on the visual system rather than leaving them in informal knowledge.
- Test the prototype with users and compare measures before and after each controlled change, using lead time, cycle time, throughput and blocked time to guide refinement.
The outcome should not be a polished diagram preserved as documentation. It should be an evidence-backed proposal that teams can use to examine constraints, negotiate priorities and adjust the operating system. Where a proposed limit increases visible queues but shortens feedback loops, the team should assess the whole customer journey. Where integration removes manual checks without improving decision quality, the simpler visual method may remain preferable.
Prototype methods are especially useful in software because the workflow can change faster than a conventional transformation programme. A map grounded in recent work provides a baseline, while an interactive visual system makes proposed changes discussable and testable. The practical takeaway is a narrow value stream, a prototype faithful to observed work, and operational changes justified by flow evidence rather than organisational preference.