Skip to main content
Results allow Tasks and Pipelines to output values that can be used by subsequent Tasks or surfaced to users.

​
TaskResult

Defines a result produced by a Task.
​
name
string
required
Name of the result.Must be a valid identifier.
​
type
ResultsType
default:"string"
Type of the result.Values:
  • string - Single string value
  • array - Array of strings
  • object - Key-value pairs
​
description
string
Human-readable description of the result.
​
properties
map[string]PropertySpec
For object-type results, defines the structure of keys.
​
value
ResultValue
Expression to retrieve the result value from a Step.Example: $(steps.stepName.results.resultName)

​
StepResult

Defines a result produced by a Step.
​
name
string
required
Name of the step result.
​
type
ResultsType
default:"string"
Type of the result: string, array, or object.
​
description
string
Description of the result.
​
properties
map[string]PropertySpec
For object results, property definitions.

​
TaskRunResult

Represents the actual result value in a TaskRun status.
​
name
string
Name of the result.
​
type
ResultsType
Type of the result.
​
value
ResultValue
The actual value produced.Can be string, array, or object depending on type.

​
PipelineResult

Defines a result produced by a Pipeline.
​
name
string
required
Name of the pipeline result.
​
type
ResultsType
default:"string"
Type of the result.
​
description
string
Description of the result.
​
value
ResultValue
required
Expression referencing a task result.Example: $(tasks.taskName.results.resultName)

​
Writing Results

Results are written to files in the container filesystem:

​
String Results

steps:
  - name: generate-version
    image: bash
    script: |
      #!/usr/bin/env bash
      echo -n "1.2.3" > $(results.version.path)
results:
  - name: version
    description: The generated version

​
Array Results

steps:
  - name: list-files
    image: bash
    script: |
      #!/usr/bin/env bash
      ls -1 | jq -R -s -c 'split("\n")[:-1]' > $(results.files.path)
results:
  - name: files
    type: array
    description: List of files

​
Object Results

steps:
  - name: get-metadata
    image: bash
    script: |
      #!/usr/bin/env bash
      echo -n '{"commit":"abc123","author":"user"}' > $(results.metadata.path)
results:
  - name: metadata
    type: object
    properties:
      commit:
        type: string
      author:
        type: string

​
Reading Results

​
In Subsequent Tasks

Reference results from previous tasks: 
tasks:
  - name: get-version
    taskRef:
      name: version-task
  - name: build
    taskRef:
      name: build-task
    params:
      - name: version
        value: $(tasks.get-version.results.version)
    runAfter:
      - get-version

​
In Pipeline Results

Surface task results as pipeline results: 
apiVersion: tekton.dev/v1
kind: Pipeline
spec:
  tasks:
    - name: build
      taskRef:
        name: build-image
  results:
    - name: image-digest
      description: Digest of the built image
      value: $(tasks.build.results.digest)

​
In Finally Tasks

Finally tasks can access results from DAG tasks: 
finally:
  - name: report
    taskRef:
      name: send-notification
    params:
      - name: version
        value: $(tasks.build.results.version)

​
Result Size Limits

Results have size limits:
  • String results: 4096 bytes (4 KB) by default
  • Array/Object results: Configured per installation
Results exceeding limits cause task failure with reason TaskRunResultLargerThanAllowedLimit.

​
Step Results

Steps can produce results that tasks aggregate: 
steps:
  - name: step-one
    image: bash
    script: |
      echo -n "value1" > $(step.results.output.path)
    results:
      - name: output
  - name: step-two
    image: bash
    script: |
      echo -n "value2" > $(step.results.output.path)
    results:
      - name: output
  - name: combine
    image: bash
    script: |
      echo "$(steps.step-one.results.output),$(steps.step-two.results.output)" \
        > $(results.combined.path)
results:
  - name: combined
    description: Combined output from both steps

​
Example: Complete Task with Results

apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: git-info
spec:
  params:
    - name: url
      type: string
  results:
    - name: commit
      type: string
      description: The current commit SHA
    - name: branch
      type: string
      description: The current branch
    - name: metadata
      type: object
      description: Git metadata
      properties:
        author:
          type: string
        date:
          type: string
  steps:
    - name: get-info
      image: alpine/git
      script: |
        #!/bin/sh
        git clone $(params.url) repo
        cd repo
        
        # Write string results
        git rev-parse HEAD > $(results.commit.path)
        git rev-parse --abbrev-ref HEAD > $(results.branch.path)
        
        # Write object result
        echo -n "{\"author\":\"$(git log -1 --format='%an')\"," \
          "\"date\":\"$(git log -1 --format='%ai')\"}" \
          > $(results.metadata.path)

​
Best Practices

  1. Keep results small - Use results for metadata, not large data
  2. Use descriptive names - Make result purpose clear
  3. Document result format - Describe expected structure
  4. Validate result content - Check that written values are valid
  5. Use appropriate types - Choose string/array/object based on data
  6. Write atomically - Write complete result value in one operation

Build docs developers (and LLMs) love

Get started for freeTalk to us