Software Types

Element types that document technical architecture, implementation and quality artefacts.

Software types document technical architecture, implementation, and quality artefacts — systems, services, interfaces, data, tests, defects, and delivery infrastructure. In the editor they live under Types → Domains → Software.

Every type below can be a bpmn:task or — once it has children — a bpmn:subProcess container; types marked container by default are placed as containers. All of them accept the universal attributes. In the tables, dai:-prefixed keys are attributes on the element; keys marked † are stored as <dai:field key="…"> children (see Where values go).

There are 20 types in this category: Client, Component, Config, Database, Decision, Dependency, Endpoint, Environment, Event, Feature Flag, Interface, Issue, Job, Model, Pipeline, Queue, Repository, Service, System, Test.

Client

dai:type="dai.types.software.client" · no dai:stepType

An application people use to reach the system: a web, mobile or desktop app, a CLI or an SDK. Different from Cloud → Client / User, which models the network actor.

Key	Label	Input	Values / notes
`clientType` †	Type	select	`web` · `mobile` · `desktop` · `cli` · `sdk` · `other`
`platform` †	Platform	text	e.g. iOS, Android, browser, macOS
`framework` †	Framework	text	e.g. React, SwiftUI, Flutter
`url` †	URL / store link	text
`auth` †	Auth	select	`none` · `session` · `oauth` · `api-key` · `other`
`dai:owner`	Owner	text	Responsible person or team
`dai:notes`	Notes	textarea

Component

dai:type="dai.types.software.component" · dai:stepType="component"

A UI or software component — its type, props/interface, and usage. Use it to document a component library, design system, or reusable building blocks.

Key	Label	Input	Values / notes
`dai:componentType`	Type	select	`ui` · `layout` · `page` · `hook` · `utility` · `service` · `library`
`dai:propsInterface`	Props / Interface	code	e.g. `interface Props { value: string; onChange: (v: string) => void; disabled?: boolean; }`
`dai:notes`	Description	textarea	What does this component do? Include usage examples and important behaviour.

<bpmn:task id="Task_comp" name="DatePicker" dai:type="dai.types.software.component" dai:stepType="component"
  dai:componentType="ui"
  dai:propsInterface="interface Props { value: string; onChange: (v: string) =&gt; void; disabled?: boolean; }" />

Config

dai:type="dai.types.software.config" · no dai:stepType

Configuration for a service or environment: settings, feature switches and secret references, and where they come from.

Key	Label	Input	Values / notes
`dai:format`	Format	select	`env` · `yaml` · `json` · `toml` · `properties` · `other`
`dai:source`	Source	select	`file` · `config-service` · `vault` · `env` · `other`
`dai:path`	Path / key	text	e.g. config/production.yaml
`dai:properties` (child element)	Settings	key-value
`dai:notes`	Notes	textarea

Database

dai:type="dai.types.software.database" · dai:stepType="database"

A database or data store — engine, host, schema, and access patterns. Documents the data layer alongside Model and Endpoint elements.

Key	Label	Input	Values / notes
`dai:engine`	Engine	select	`postgresql` · `mysql` · `sqlite` · `mongodb` · `redis` · `dynamodb` · `firestore` · `other`
`dai:host`	Host	text	e.g. db.example.com or localhost
`schema` †	Schema	text	Database or schema name
`dai:accessPattern`	Access Pattern	textarea	How is this database accessed? Read-heavy? Write-heavy? Used as a cache? Any connection pooling or replication notes?
`dai:notes`	Notes	textarea

<bpmn:task id="Task_db" name="Orders DB" dai:type="dai.types.software.database" dai:stepType="database"
  dai:engine="postgresql" dai:host="db.example.com"
  dai:accessPattern="Write-heavy during business hours; read replicas serve reporting queries.">
  <bpmn:extensionElements>
    <dai:fields>
      <dai:field key="schema">orders</dai:field>
    </dai:fields>
  </bpmn:extensionElements>
</bpmn:task>

Decision

dai:type="dai.types.software.decision" · no dai:stepType

A technical or architecture decision record (ADR): the context, the options considered, the decision and its consequences. For business decisions use Business → Decision.

Key	Label	Input	Values / notes
`dai:status`	Status	select	`proposed` · `accepted` · `deprecated` · `superseded`; default `proposed`
`dai:context`	Context	textarea
`options` †	Options considered	textarea
`dai:decision`	Decision	textarea
`dai:consequences`	Consequences	textarea
`deciders` †	Deciders	text
`decidedOn` †	Date	text	e.g. 2026-10-12
`dai:notes`	Notes	textarea

Dependency

dai:type="dai.types.software.dependency" · dai:stepType="dependency"

An external library, package, service, API, or resource the project relies on. Documents source, version, type, and license for dependency management and compliance.

Key	Label	Input	Values / notes
`dai:package`	Package	text	npm package, pip module, or repo URL
`dai:version`	Version	text	e.g. ^18.2.0, >=3.10, 2.1.4
`dai:dependencyType`	Type	select	`runtime` · `dev` · `peer` · `optional`
`dai:license`	License	text	e.g. MIT, Apache 2.0, GPL-3.0
`dai:purpose`	Purpose	textarea	Why is this dependency needed? What does it provide?
`dai:notes`	Notes	textarea

<bpmn:task id="Task_dep" name="stripe-node" dai:type="dai.types.software.dependency" dai:stepType="dependency"
  dai:package="stripe" dai:version="^16.8.0" dai:dependencyType="runtime"
  dai:license="MIT" dai:purpose="Server-side charging of saved payment methods." />

Endpoint

dai:type="dai.types.software.api-endpoint" · dai:stepType="api-endpoint"

Defines a REST or GraphQL API endpoint — its method, path, auth, and request/response schemas. The service field names the owning Service (or draw a connection from a Service element on canvas to link them).

Key	Label	Input	Values / notes
`service` †	Service	text	Which service owns this endpoint?; Type the name of a Service, or draw a connection from a Service element on canvas to this endpoint to link them.
`dai:method`	HTTP Method	select	`GET` · `POST` · `PUT` · `PATCH` · `DELETE` · `OPTIONS`
`dai:path`	Path	text	/api/v1/resource/{id}
`dai:statusCode`	Status Code	text	e.g. 200, 201, 204
`dai:authType`	Auth	select	`none` · `bearer` · `api-key` · `oauth2` · `basic`
`dai:requestBody`	Request Schema	code	e.g. `{ "field": "type" }`
`dai:responseBody`	Response Schema	code	e.g. `{ "field": "type" }`
`dai:notes`	Description	textarea	What does this endpoint do? Include any important behaviour or limitations.

<bpmn:task id="Task_api" name="POST /api/reports/:id/export" dai:type="dai.types.software.api-endpoint" dai:stepType="api-endpoint"
  dai:method="POST" dai:path="/api/reports/:id/export" dai:authType="bearer"
  dai:statusCode="200"
  dai:notes="Accepts a column selection and returns a CSV file stream.">
  <bpmn:extensionElements>
    <dai:fields>
      <dai:field key="service">Reporting Service</dai:field>
    </dai:fields>
  </bpmn:extensionElements>
</bpmn:task>

Environment

dai:type="dai.types.software.environment" · dai:stepType="environment" · container by default

A deployment environment — dev, staging, production, or any named runtime target. It is placed as a container — a bpmn:subProcess once it holds children — to group the services, databases, and components deployed in it. A System is what is built and released together; an Environment is where it runs.

Key	Label	Input	Values / notes
`envType` †	Type	select	`development` · `staging` · `production` · `testing` · `other`
`url` †	URL	text	e.g. https://staging.example.com
`dai:notes`	Notes	textarea	Describe this environment, its purpose, and any access requirements.

<bpmn:subProcess id="Env_staging" name="Staging" dai:type="dai.types.software.environment" dai:stepType="environment"
  dai:notes="Deployed from the release pipeline on every tagged build.">
  <bpmn:extensionElements>
    <dai:fields>
      <dai:field key="envType">staging</dai:field>
      <dai:field key="url">https://staging.example.com</dai:field>
    </dai:fields>
  </bpmn:extensionElements>
  <bpmn:task id="Task_svc" name="Payment Service" dai:type="dai.types.software.service" dai:stepType="service" … />
</bpmn:subProcess>

Event

dai:type="dai.types.software.event" · dai:stepType="event"

A domain event in an event-driven or microservice architecture — producer, consumers, payload schema, and broker. Documents the async contracts between services.

Key	Label	Input	Values / notes
`dai:producer`	Producer	text	Which service or component emits this event?
`dai:consumers`	Consumers	textarea	Which services or components listen for this event?
`dai:broker`	Broker	select	`kafka` · `rabbitmq` · `aws-sns` · `aws-sqs` · `gcp-pubsub` · `redis-pubsub` · `custom` · `none`
`dai:payloadSchema`	Payload Schema	code	e.g. `{ "orderId": "uuid", "userId": "uuid", "total": "number", "createdAt": "ISO8601" }`
`dai:notes`	Notes	textarea

<bpmn:task id="Task_event" name="order.confirmed" dai:type="dai.types.software.event" dai:stepType="event"
  dai:producer="Order Service" dai:consumers="Fulfilment Service, Notification Service"
  dai:broker="kafka"
  dai:payloadSchema="{&quot;orderId&quot;: &quot;uuid&quot;, &quot;total&quot;: &quot;number&quot;, &quot;createdAt&quot;: &quot;ISO8601&quot;}" />

Feature Flag

dai:type="dai.types.software.feature-flag" · no dai:stepType

A runtime toggle that turns behaviour on or off without a deploy, for releases, experiments, operations or permissions. Records its key, default, rollout and when to remove it.

Key	Label	Input	Values / notes
`flagKey` †	Flag key	text	e.g. new-checkout
`flagType` †	Type	select	`release` · `experiment` · `ops` · `permission`; default `release`
`defaultValue` †	Default	text	e.g. off
`rollout` †	Rollout %	number	0–100
`provider` †	Provider	select	`openfeature` · `launchdarkly` · `unleash` · `flagsmith` · `config` · `other`
`dai:status`	Status	select	`active` · `rolled-out` · `removed`; default `active`
`removeBy` †	Remove by	text	e.g. 2027-01-31
`dai:owner`	Owner	text	Responsible person or team
`dai:notes`	Notes	textarea

Interface

dai:type="dai.types.software.interface" · no dai:stepType

A contract between parts of the system that is more than one HTTP endpoint: an OpenAPI, GraphQL, gRPC or AsyncAPI spec, a library or SDK interface, a CLI or a file format. Endpoint is a single operation; Model is a data shape.

Key	Label	Input	Values / notes
`interfaceType` †	Type	select	`rest` · `graphql` · `grpc` · `async` · `library` · `cli` · `file` · `other`
`dai:format`	Spec format	select	`openapi` · `graphql` · `protobuf` · `asyncapi` · `typescript` · `json-schema` · `other`
`spec` †	Spec	code	e.g. `Paste or summarise the contract`
`dai:version`	Version	text
`specUrl` †	Spec link	text	https://…
`dai:owner`	Owner	text	Responsible person or team
`dai:notes`	Notes	textarea

Issue

dai:type="dai.types.software.issue" · dai:stepType="issue"

A bug, defect, or blocker that needs to be tracked and resolved. Captures severity, type, reproduction steps, and expected vs actual behaviour.

Key	Label	Input	Values / notes
`dai:issueType`	Type	select	`bug` · `enhancement` · `blocker` · `question`
`dai:severity`	Severity	select	`critical` · `high` · `medium` · `low`
`dai:status`	Status	select	`open` · `in-progress` · `resolved` · `closed` · `wont-fix`
`dai:stepsToReproduce`	Steps to Reproduce	textarea	1. Go to… 2. Click on… 3. Observe…
`expectedResult` †	Expected	textarea	What should happen?
`actualResult` †	Actual	textarea	What actually happens?
`dai:assignee`	Assignee	text	Who is fixing this?
`dai:notes`	Notes	textarea

<bpmn:task id="Task_issue" name="Date timezone offset bug" dai:type="dai.types.software.issue" dai:stepType="issue"
  dai:issueType="bug" dai:severity="medium" dai:status="open" dai:assignee="@maya"
  dai:stepsToReproduce="1. Export a report. 2. Open in Excel on a UTC+8 machine.">
  <bpmn:extensionElements>
    <dai:fields>
      <dai:field key="expectedResult">Dates match the values shown in the UI.</dai:field>
      <dai:field key="actualResult">Dates are offset by the user's local timezone.</dai:field>
    </dai:fields>
  </bpmn:extensionElements>
</bpmn:task>

Job

dai:type="dai.types.software.job" · no dai:stepType

A background or scheduled worker that runs to completion: triggered by a schedule, a queue, an event or by hand. Pipeline stays CI/CD.

Key	Label	Input	Values / notes
`dai:trigger`	Trigger	select	`schedule` · `queue` · `event` · `manual`; default `schedule`
`schedule` †	Schedule	text	Cron, e.g. 0 3 * * *
`runtime` †	Runtime	text	e.g. Node.js worker, Sidekiq, Celery
`timeout` †	Timeout	text	e.g. 15m
`retries` †	Retries	number	min 0; default `3`
`idempotent` †	Idempotent	boolean	default `false`
`dai:owner`	Owner	text	Responsible person or team
`dai:notes`	Notes	textarea

Model

dai:type="dai.types.software.model" · dai:stepType="model"

A data schema or structured type definition. Documents the shape of data flowing through the system and the notation used. Fields are declared with dai:properties.

Key	Label	Input	Values / notes
`dai:modelFormat`	Format	select	`typescript` · `json-schema` · `sql` · `protobuf` · `avro` · `plain`
`dai:notes`	Description	textarea	What does this model represent? How is it used?
`dai:properties` (child element)	Properties	key-value

<bpmn:task id="Task_model" name="OrderLine" dai:type="dai.types.software.model" dai:stepType="model" dai:modelFormat="plain"
  dai:notes="A single line item within an order.">
  <bpmn:extensionElements>
    <dai:properties>
      <dai:property name="productId" type="str" />
      <dai:property name="quantity"  type="int" />
      <dai:property name="unitPrice" type="float" />
    </dai:properties>
  </bpmn:extensionElements>
</bpmn:task>

Pipeline

dai:type="dai.types.software.pipeline" · dai:stepType="pipeline"

A CI/CD or release pipeline. Documents the stages, trigger, toolchain, and target environment for a build, test, or deployment process.

Key	Label	Input	Values / notes
`dai:trigger`	Trigger	select	`push` · `pr` · `schedule` · `manual`
`tool` †	Tool	text	e.g. GitHub Actions, Jenkins, CircleCI
`stages` †	Stages	textarea	List the pipeline stages, e.g. lint → test → build → deploy
`targetEnvironment` †	Target Environment	text	e.g. staging, production
`dai:notes`	Notes	textarea	Additional context, dependencies, or failure handling.

<bpmn:task id="Task_ci" name="Release pipeline" dai:type="dai.types.software.pipeline" dai:stepType="pipeline"
  dai:trigger="push">
  <bpmn:extensionElements>
    <dai:fields>
      <dai:field key="tool">GitHub Actions</dai:field>
      <dai:field key="stages">lint → test → build → deploy</dai:field>
      <dai:field key="targetEnvironment">staging</dai:field>
    </dai:fields>
  </bpmn:extensionElements>
</bpmn:task>

Queue

dai:type="dai.types.software.queue" · no dai:stepType

A message queue, topic or stream that carries messages between services. Event describes the message contract; Queue is the channel it travels on.

Key	Label	Input	Values / notes
`dai:broker`	Technology	select	`rabbitmq` · `kafka` · `sqs` · `nats` · `redis` · `pubsub` · `other`
`pattern` †	Pattern	select	`queue` · `topic` · `stream`; default `queue`
`dai:producer`	Producers	text
`dai:consumers`	Consumers	text
`delivery` †	Delivery guarantee	select	`at-most-once` · `at-least-once` · `exactly-once`
`deadLetter` †	Dead-letter queue	text
`dai:notes`	Notes	textarea

Repository

dai:type="dai.types.software.repository" · dai:stepType="repository"

A source control repository. Documents the URL, hosting platform, primary branch, and visibility to make the code location explicit alongside the components and services that depend on it.

Key	Label	Input	Values / notes
`url` †	URL	text	e.g. https://github.com/org/repo
`platform` †	Platform	select	`github` · `gitlab` · `bitbucket` · `azure` · `other`
`branch` †	Primary Branch	text	main
`visibility` †	Visibility	select	`public` · `private` · `internal`
`dai:notes`	Notes	textarea	Describe this repository, its contents, and any access requirements.

<bpmn:task id="Task_repo" name="ex_auth" dai:type="dai.types.software.repository" dai:stepType="repository">
  <bpmn:extensionElements>
    <dai:fields>
      <dai:field key="url">https://github.com/dai-studio/ex_auth</dai:field>
      <dai:field key="platform">github</dai:field>
      <dai:field key="branch">main</dai:field>
      <dai:field key="visibility">public</dai:field>
    </dai:fields>
  </bpmn:extensionElements>
</bpmn:task>

Service

dai:type="dai.types.software.service" · dai:stepType="service"

An external or internal service — its base URL, auth scheme, and version. Provides the context for Endpoint elements that belong to it; connect endpoints to a Service element with sequence flows to link them.

Key	Label	Input	Values / notes
`dai:baseUrl`	Base URL	text	https://api.example.com
`dai:version`	Version	text	e.g. v2, 2.1.0
`dai:authType`	Auth	select	`none` · `bearer` · `api-key` · `oauth2` · `basic`
`dai:notes`	Description	textarea	What does this service do? Include ownership, SLA, and any important constraints.

<bpmn:task id="Task_svc" name="Payment Service" dai:type="dai.types.software.service" dai:stepType="service"
  dai:baseUrl="https://payments.internal.example.com" dai:version="2.1.0" dai:authType="oauth2" />

System

dai:type="dai.types.software.system" · no dai:stepType · container by default

A software system: the Services, Clients, Databases, Queues and Jobs that are owned and released together. Contains its parts; Environment is where they are deployed.

Key	Label	Input	Values / notes
`boundary` †	Boundary	select	`internal` · `external`; default `internal`
`dai:status`	Status	select	`planned` · `building` · `live` · `deprecated` · `retired`; default `live`
`docsUrl` †	Docs	text	https://…
`dai:owner`	Owning team	text	Responsible person or team
`dai:notes`	Notes	textarea

Test

dai:type="dai.types.software.test" · dai:stepType="test"

A test case or verification condition — documents what is being tested, how to run it, and what constitutes a pass.

Key	Label	Input	Values / notes
`dai:testType`	Type	select	`unit` · `integration` · `e2e` · `acceptance` · `performance` · `security`
`dai:testStatus`	Status	select	`not-run` · `passing` · `failing` · `skipped`
`dai:testSteps`	Steps	textarea	How do you run this test? List the steps.
`expectedResult` †	Expected Result	textarea	What should happen when the test passes?
`actualResult` †	Actual Result	textarea	What actually happened? (fill in after running)
`dai:notes`	Notes	textarea

<bpmn:task id="Task_test" name="Basic export works" dai:type="dai.types.software.test" dai:stepType="test"
  dai:testType="e2e" dai:testStatus="not-run"
  dai:testSteps="1. Open any report. 2. Click Export. 3. Select all columns. 4. Click Download.">
  <bpmn:extensionElements>
    <dai:fields>
      <dai:field key="expectedResult">A CSV file downloads containing all report rows and selected columns.</dai:field>
    </dai:fields>
  </bpmn:extensionElements>
</bpmn:task>

For AI-specific eval suites, see Evaluation.

About DAI.Studio