diff --git a/content/templates/_index.md b/content/templates/_index.md
index f4f4beb88..e6eb3ec4a 100644
--- a/content/templates/_index.md
+++ b/content/templates/_index.md
@@ -8,3 +8,117 @@ menu:
   main:
     weight: 405
 ---
+
+A template is a pipeline with one to many defined steps that can be sourced into another pipeline. Templates can live in any repository in a [source control system](/docs/concepts/infrastructure/server/source/) and are expanded at compile time to create the final executable pipeline.
+
+Templates can take the form of generalized workflows across repositories or complex workflows like matrices in a single build.
+
+{{% alert color="warning" %}}
+The following YAML tags are not valid inside a template pipeline:
+
+* `services:`
+* `secrets:`
+* `stages:`
+* `templates:`
+{{% /alert %}}
+
+## Template Engines
+
+### Format
+
+By default, templates utilize the Go template language unless otherwise specified. You may opt to specify the `format` key to switch the template language to one of the following:
+
+* `format: go`
+* `format: golang`
+* `format: ""`
+* `format: starlark`
+
+### Go Template
+
+[Go Templates](https://golang.org/pkg/text/template/) is the default formatter for building out template pipelines. We extend Go's built-in template functions by utilizing the [sprig library](http://masterminds.github.io/sprig/) in the engine to allow for more options on top of the Go template syntax.
+
+Let's take a look at a basic template:
+
+{{% alert color="tip" %}}
+For this example we will call it `build.yml` but the YAML does not have a required name.
+{{% /alert %}}
+
+```yaml
+metadata:
+  template: true
+
+steps:
+  - name: Test and Build
+    commands:
+      - go test ./...
+      - go build
+    image: {{ .image }}
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: go
+    source: github.com/octocat/hello-world/.vela/build.yml
+    format: go
+    type: github
+
+steps:
+  - name: sample
+    template:
+      name: go
+      vars:
+        image: golang:latest
+```
+
+### Starlark
+
+[Starlark](https://github.com/bazelbuild/starlark) is a configuration language that was designed for the [Bazel build system](https://bazel.build/). The language is a [Python](https://www.python.org/) dialect that exists for advanced configuration management that can require complex structures. The language is dynamically typed and allows for all sorts of language-esque primitives to make writing large configuration files more manageable.
+
+It is recommended users read the [Starlark Spec](https://github.com/bazelbuild/starlark/blob/master/spec.md) to understand the syntax differences between Python and Starlark. Python IDE tools are compatible with Starlark to assist users in writing their `.star` or `.py` template pipelines.
+
+Let's take a look at a basic template:
+
+{{% alert color="tip" %}}
+For this example we will call it `build.star` but the file does not have a required name.
+{{% /alert %}}
+
+```python
+def main(ctx):
+  return {
+    'version': '1',
+    'steps': [
+      {
+        'name': 'build',
+        'image': ctx["vars"]["image"],
+        'commands': [
+          'go build',
+          'go test',
+        ]
+      },
+    ],
+}
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: starlark
+    source: github.com/octocat/hello-world/.vela/build.star
+    format: starlark
+    type: github
+
+steps:
+  - name: sample
+    template:
+      name: starlark
+      vars:
+        image: golang:latest
+```
diff --git a/content/templates/overview.md b/content/templates/overview.md
deleted file mode 100644
index 0bc902823..000000000
--- a/content/templates/overview.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: "Overview"
-linkTitle: "Overview"
-description: >
-  Learn about Templates for Vela.
----
-
-A template is a pipeline with one to many defined steps that can be sourced into another pipeline. Templates can live in any repository in a [source control system](/docs/concepts/infrastructure/server/source/) and are expanded at compile time to create the final executable pipeline.
-
-Templates can take the form of generalized workflows across repositories or complex workflows like matrices in a single build.
-
-{{% alert color="warning" %}}
-The following YAML tags are not valid inside a template pipeline:
-
-* `services:`
-* `secrets:`
-* `stages:`
-* `templates:`
-{{% /alert %}}
-
-## Template Engines
-
-At this time the only supported template engine is [Go Templates](https://golang.org/pkg/text/template/). We extend Go's built-in template functions by utilizing the [sprig library](http://masterminds.github.io/sprig/) in the engine to allow for more options on top of the Go template syntax.
-
-Let's take a look at a basic template:
-
-{{% alert color="tip" %}}
-For this example we will call it build.yml but the YAML does not have a required name.
-{{% /alert %}}
-
-```yaml
-metadata:
-  template: true
-
-steps:
-  - name: Test and Build
-    commands:
-      - go test ./...
-      - go build
-    image: {{ .image }}
-    pull: always
-    ruleset:
-      event: [ push, pull_request ]
-```
-
-The caller of this template could look like:
-
-```yaml
-version: "1"
-templates:
-  - name: sample
-    source: github.com/octocat/hello-world/.vela/build.yml
-    type: github
-
-steps:
-  - name: golang
-    template:  
-      name: sample
-      vars:
-        image: golang:latest
-```
diff --git a/content/templates/registry/_index.md b/content/templates/registry/_index.md
deleted file mode 100644
index c037ecc69..000000000
--- a/content/templates/registry/_index.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Registry"
-linkTitle: "Registry"
-description: >
-  List of community templates to customize Vela pipelines.
----
-
-COMING SOON!
diff --git a/content/templates/tutorials/_index.md b/content/templates/tutorials/_index.md
index 0df425da1..5a9cf6d90 100644
--- a/content/templates/tutorials/_index.md
+++ b/content/templates/tutorials/_index.md
@@ -4,3 +4,9 @@ linkTitle: "Tutorials"
 description: >
   Learn how to write your own templates for Vela.
 ---
+
+{{% alert title="Note:" color="primary" %}}
+Pipeline templates are an advanced way to write pipelines. We strongly recommend you have a grasp on the following concepts before continuing:
+
+* [Steps](/docs/concepts/pipeline/steps/)
+{{% /alert %}}
diff --git a/content/templates/tutorials/go/_index.md b/content/templates/tutorials/go/_index.md
new file mode 100644
index 000000000..fae64b676
--- /dev/null
+++ b/content/templates/tutorials/go/_index.md
@@ -0,0 +1,6 @@
+---
+title: "Go"
+linkTitle: "Go"
+description: >
+  See examples on how to write Go templates.
+---
diff --git a/content/templates/tutorials/conditional.md b/content/templates/tutorials/go/conditional.md
similarity index 94%
rename from content/templates/tutorials/conditional.md
rename to content/templates/tutorials/go/conditional.md
index 57193937e..55c669823 100644
--- a/content/templates/tutorials/conditional.md
+++ b/content/templates/tutorials/go/conditional.md
@@ -2,7 +2,7 @@
 title: "Conditionals"
 linkTitle: "Conditionals"
 description: >
-  Learn how to write a Vela template with conditionals.
+  Example Go template with conditionals.
 ---
 
 {{% alert color="note" %}}
@@ -39,7 +39,7 @@ Let's take a look at using a conditional with a variable in a template:
 metadata:
   template: true
 
-{{$br := .branch}}
+{{$br := vela "BUILD_BRANCH"}}
 
 steps:
 
@@ -76,12 +76,11 @@ templates:
 
 steps:
   - name: golang
-    template:  
+    template:
       name: sample
       vars:
         image: golang:latest
         pull_policy: "pull: always"
-        branch: master
 ```
 
 Which means the compiled pipeline for execution on a worker is:
diff --git a/content/templates/tutorials/loops_maps.md b/content/templates/tutorials/go/loops_maps.md
similarity index 97%
rename from content/templates/tutorials/loops_maps.md
rename to content/templates/tutorials/go/loops_maps.md
index 3df8cb370..8332df585 100644
--- a/content/templates/tutorials/loops_maps.md
+++ b/content/templates/tutorials/go/loops_maps.md
@@ -2,7 +2,7 @@
 title: "Loops with Maps"
 linkTitle: "Loops with Maps"
 description: >
-  Learn how to write a Vela template with loops and maps.
+  Example Go template with loops and maps.
 ---
 
 {{% alert color="note" %}}
@@ -77,7 +77,7 @@ templates:
 
 steps:
   - name: golang
-    template:  
+    template:
       name: sample
       vars:
         pull_policy: "pull: always"
diff --git a/content/templates/tutorials/loops_slice.md b/content/templates/tutorials/go/loops_slice.md
similarity index 97%
rename from content/templates/tutorials/loops_slice.md
rename to content/templates/tutorials/go/loops_slice.md
index 337d659ab..da8b89141 100644
--- a/content/templates/tutorials/loops_slice.md
+++ b/content/templates/tutorials/go/loops_slice.md
@@ -2,7 +2,7 @@
 title: "Loops with Slices"
 linkTitle: "Loops with Slices"
 description: >
-  Learn how to write a Vela template with loops and slices.
+  Example Go template with loops and slices.
 ---
 
 {{% alert color="note" %}}
diff --git a/content/templates/tutorials/mulitline.md b/content/templates/tutorials/go/mulitline.md
similarity index 96%
rename from content/templates/tutorials/mulitline.md
rename to content/templates/tutorials/go/mulitline.md
index 95342ce29..f84b5397e 100644
--- a/content/templates/tutorials/mulitline.md
+++ b/content/templates/tutorials/go/mulitline.md
@@ -2,7 +2,7 @@
 title: "Multiline"
 linkTitle: "Multiline"
 description: >
-  Learn how to write a Vela template that passes multiline strings.
+  Example Go template with multiline strings.
 ---
 
 {{% alert color="note" %}}
diff --git a/content/templates/tutorials/go/vars_platform.md b/content/templates/tutorials/go/vars_platform.md
new file mode 100644
index 000000000..710ac5c8d
--- /dev/null
+++ b/content/templates/tutorials/go/vars_platform.md
@@ -0,0 +1,72 @@
+---
+title: "Platform Vars"
+linkTitle: "Platform Vars"
+description: >
+  Example Go template with platform vars.
+---
+
+{{% alert color="note" %}}
+We recommend reviewing [Go Templates documentation](https://golang.org/pkg/text/template/) before attempting to create a template.
+
+If you're new to YAML we also recommend reviewing the [YAML 1.2 spec](https://yaml.org/spec/1.2/spec.html) for validation on syntax.
+{{% /alert %}}
+
+## Overview
+
+Platform variables can be referenced with the following syntax:
+
+`{{ vela "<environment variable>" }}`
+
+## Examples
+
+- `{{ vela "VELA_FULL_REPO_NAME" }}` equates to the `VELA_FULL_REPO_NAME` environment variable
+- `{{ vela "FULL_REPO_NAME" }}` equates to the `VELA_REPO_NAME` environment variable
+- `{{ vela "VELA_BUILD_NUMBER" }}` equates to the `VELA_BUILD_NUMBER` environment variable
+- `{{ vela "VELA_ADDR" }}` equates to the `VELA_ADDR` environment variable
+
+## Sample
+
+Let's take a look at using a platform variable in a template:
+
+```yaml
+metadata:
+  template: true
+
+steps:
+  - name: test
+    commands:
+      - echo {{ vela "VELA_REPO_FULL_NAME" }}
+    image: alpine
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: sample
+    source: github.com/<org>/<repo>/path/to/file/<template>.yml
+    type: github
+
+steps:
+  - name: sample
+    template:
+      name: echo
+```
+
+Which means the compiled pipeline for execution on a worker is:
+
+```yaml
+version: "1"
+steps:
+  - name: sample_echo
+    commands:
+      - echo github/octocat
+    image: alpine
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+```
diff --git a/content/templates/tutorials/starlark/_index.md b/content/templates/tutorials/starlark/_index.md
new file mode 100644
index 000000000..4bb4f727c
--- /dev/null
+++ b/content/templates/tutorials/starlark/_index.md
@@ -0,0 +1,6 @@
+---
+title: "Starlark"
+linkTitle: "Starlark"
+description: >
+  See examples on how to write Starlark templates.
+---
diff --git a/content/templates/tutorials/starlark/anatomy.md b/content/templates/tutorials/starlark/anatomy.md
new file mode 100644
index 000000000..af87d6bcb
--- /dev/null
+++ b/content/templates/tutorials/starlark/anatomy.md
@@ -0,0 +1,81 @@
+---
+title: "Anatomy"
+linkTitle: "Anatomy"
+description: >
+  Starlark template anatomy.
+---
+
+## Anatomy
+
+In order to make Starlark work with Vela's templates functionality we did have to make a few design decisions on behalf of the users.
+
+### All templates must contain a "main" function that returns the pipeline
+
+This is illustrated in the below example with a starlark file that contains a `def main(ctx)` and returns the data structure that is a valid pipeline.
+
+```python
+def main(ctx):
+  return {
+    'version': '1',
+    'steps': [
+      {
+        'name': 'build',
+        'image': golang:latest,
+        'commands': [
+          'go build',
+          'go test',
+        ]
+      },
+    ],
+}
+```
+
+### Context is used by the compiler to pass information to the template
+
+The compiler will inject user variables defined in the parent template and compile time platform variables. Both sets of variables are injected into the context within a dictionary structure.
+
+#### Platform variables
+
+Syntax: `ctx['vela']['<resource>']['<name>']`
+
+```python
+def main(ctx):
+  repo = ctx["vela"]["repo"]["full_name"]
+
+  return {
+    'version': '1',
+    'steps': [
+      {
+        'name': 'build',
+        'image': golang:latest,
+        'commands': [
+          "go build %s" %, repo,
+          'go test',
+        ]
+      },
+    ],
+}
+```
+
+#### Template variables
+
+Syntax: `ctx['vars'][<name>]`
+
+```python
+def main(ctx):
+  image = ctx['vars']['image']
+
+  return {
+    'version': '1',
+    'steps': [
+      {
+        'name': 'build',
+        'image': image,
+        'commands': [
+          'go build',
+          'go test',
+        ]
+      },
+    ],
+}
+```
diff --git a/content/templates/tutorials/starlark/conditional.md b/content/templates/tutorials/starlark/conditional.md
new file mode 100644
index 000000000..572b7b72d
--- /dev/null
+++ b/content/templates/tutorials/starlark/conditional.md
@@ -0,0 +1,111 @@
+---
+title: "Conditionals"
+linkTitle: "Conditionals"
+description: >
+  Example Starlark template with conditionals.
+---
+
+{{% alert color="note" %}}
+We recommend reviewing [Starlark Spec](https://github.com/bazelbuild/starlark/blob/master/spec.md) before attempting to create a template.
+{{% /alert %}}
+
+## Overview
+
+From [Starlark Conditional Expressions](https://github.com/google/starlark-go/blob/master/doc/spec.md#conditional-expressions):
+
+```text
+"yes" if enabled else "no"
+```
+
+{{% alert color="tip" %}}
+For information on if/else statements see [conditional docs](https://github.com/google/starlark-go/blob/master/doc/spec.md#conditional-expressions)
+{{% /alert %}}
+
+## Sample
+
+Let's take a look at using a conditional with a variable in a template:
+
+```python
+def main(ctx):
+  steps = [
+              {
+                  "name": "test",
+                  "image": ctx["vars"]["image"],
+                  "commands": [
+                      "go test ./..."
+                  ],
+                  "pull": ctx["vars"]["pull_policy"],
+                  "ruleset": {
+                      "event": [
+                          "push",
+                          "pull_request"
+                      ]
+                  }
+              }
+          ]
+
+  # if branch equals master add this step to the final pipeline
+  if ctx["vela"]["build"]["branch"] == "master":
+      steps.append(
+          {
+              "name": "build",
+              "image": ctx["vars"]["image"],
+              "commands": [
+                  "go build"
+              ],
+              "pull": ctx["vars"]["pull_policy"],
+              "ruleset": {
+                  "event": [
+                      "push",
+                      "pull_request"
+                  ]
+              }
+          }
+      )
+
+  return {
+      'version': '1',
+      'steps': steps,
+  }
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: sample
+    source: github.com/<org>/<repo>/path/to/file/<template>.star
+    type: github
+    format: starlark
+
+steps:
+  - name: sample
+    template:
+      name: golang
+      vars:
+        image: golang:latest
+        pull_policy: "always"
+```
+
+Which means the compiled pipeline for execution on a worker is:
+
+```yaml
+version: "1"
+steps:
+  - name: sample_test
+    commands:
+      - go test ./...
+    image: golang:latest
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+
+  - name: sample_build
+    commands:
+      - go build
+    image: golang:latest
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+```
diff --git a/content/templates/tutorials/starlark/functions.md b/content/templates/tutorials/starlark/functions.md
new file mode 100644
index 000000000..df039ccc9
--- /dev/null
+++ b/content/templates/tutorials/starlark/functions.md
@@ -0,0 +1,89 @@
+---
+title: "Functions"
+linkTitle: "Functions"
+description: >
+  Example Starlark template with functions.
+---
+
+{{% alert color="note" %}}
+We recommend reviewing [Starlark Spec](https://github.com/bazelbuild/starlark/blob/master/spec.md) before attempting to create a template.
+{{% /alert %}}
+
+## Overview
+
+From [Starlark functions](https://github.com/bazelbuild/starlark/blob/master/spec.md#function-definitions):
+
+```star
+def twice(x):
+    return x * 2
+
+str(twice)              # "<function f>"
+twice(2)                # 4
+twice("two")            # "twotwo"
+```
+
+> The function's name is preceded by the def keyword and followed by the parameter list (which is enclosed in parentheses), a colon, and then an indented block of statements which form the body of the function.
+
+> The parameter list is a comma-separated list whose elements are of four kinds. First come zero or more required parameters, which are simple identifiers; all calls must provide an argument value for these parameters.
+
+> The required parameters are followed by zero or more optional parameters, of the form name=expression. The expression specifies the default value for the parameter for use in calls that do not provide an argument value for it.
+
+> The required parameters are optionally followed by a single parameter name preceded by a *. This is the called the varargs parameter, and it accumulates surplus positional arguments specified by a call.
+
+> Finally, there may be an optional parameter name preceded by **. This is called the keyword arguments parameter, and accumulates in a dictionary any surplus name=value arguments that do not match a prior parameter.
+
+## Sample
+
+Let's take a look at using a function within a template:
+
+```python
+def main(ctx):
+  return {
+    'version': '1',
+    'steps': [
+        step('foo'),
+        step('bar')
+    ],
+  }
+
+def step(word):
+  return {
+    "name": "build_%s" % word,
+    "image": "alpine:latest",
+    'commands': [
+        "echo %s" % word
+    ]
+  }
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: sample
+    source: github.com/<org>/<repo>/path/to/file/<template>.star
+    format: starlark
+    type: github
+
+steps:
+  - name: echo
+    template:
+      name: sample
+```
+
+Which means the compiled pipeline for execution on a worker is:
+
+```yaml
+version: 1
+steps:
+  - name: sample_build_foo
+    image: alpine:latest
+    commands:
+      - echo foo
+
+  - name: sample_build_bar
+    image: alpine:latest
+    commands:
+      - echo bar
+```
diff --git a/content/templates/tutorials/starlark/loops_map.md b/content/templates/tutorials/starlark/loops_map.md
new file mode 100644
index 000000000..4e7bbe282
--- /dev/null
+++ b/content/templates/tutorials/starlark/loops_map.md
@@ -0,0 +1,147 @@
+---
+title: "Loops with Maps"
+linkTitle: "Loops with Maps"
+description: >
+  Example Starlark template with loops and maps.
+---
+
+{{% alert color="note" %}}
+We recommend reviewing [Starlark Spec](https://github.com/bazelbuild/starlark/blob/master/spec.md) before attempting to create a template.
+{{% /alert %}}
+
+## Overview
+
+From [Starlark for loops](https://github.com/google/starlark-go/blob/master/doc/spec.md#for-loops):
+
+```python
+for i in [["a", 1], ["b", 2], ["c", 3]]:
+  print(a, i) # prints "a 1", "b 2", "c 3"
+```
+
+## Sample
+
+Let's take a look at looping over a map for a template:
+
+```python
+def main(ctx):
+  ruleset = {
+    "event": [
+      "push",
+      "pull_request"
+    ]
+  }
+
+  steps = [
+    {
+      "name": "install",
+      "image": "golang:latest",
+      "commands": [
+          "go get ./..."
+      ],
+      "pull": ctx["vars"]["pull_policy"],
+      "ruleset": ruleset,
+    }
+  ]
+
+  for name, image in ctx["vars"]["images"].items():
+    steps.append(
+        {
+          "name": "test_%s" % name,
+          "image": image,
+          "commands": [
+              "go test ./..."
+          ],
+          "pull": ctx["vars"]["pull_policy"],
+          "ruleset": ruleset,
+        }
+    )
+
+  steps.append(
+    {
+      "name": "build",
+      "image": "golang:latest",
+      "commands": [
+          "go build"
+      ],
+      "environment": {
+          "CGO_ENABLED": "0",
+          "GOOS": "linux",
+      },
+      "pull": ctx["vars"]["pull_policy"],
+      "ruleset": ruleset,
+    }
+  )
+
+  pipeline = {
+    'version': '1',
+    'steps': steps,
+  }
+
+  return pipeline
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: sample
+    source: github.com/<org>/<repo>/path/to/file/<template>.star
+    type: github
+
+steps:
+  - name: sample
+    template:
+      name: golang
+      vars:
+        pull_policy: "always"
+        images:
+          _latest: golang:latest
+          _1.13: golang:1.13
+          _1.12: golang:1.13
+```
+
+Which means the compiled pipeline for execution on a worker is:
+
+{{% alert color="warning" %}}
+Vela does not guarantee order with maps. If you need the steps to **always** be outputted in the same order use the loops with slice implementation.
+{{% /alert %}}
+
+```yaml
+version: "1"
+steps:
+  - name: sample_test_latest
+    commands:
+      - go test ./...
+    image: golang:latest
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+
+  - name: sample_test_1.13
+    commands:
+      - go test ./...
+    image: golang:1.13
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+
+  - name: sample_test_1.12
+    commands:
+      - go test ./...
+    image: golang:1.12
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+
+  - name: sample_build
+    commands:
+      - go build
+    environment:
+      CGO_ENABLED: '0'
+      GOOS: linux
+    image: golang:latest
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+```
diff --git a/content/templates/tutorials/starlark/loops_slice.md b/content/templates/tutorials/starlark/loops_slice.md
new file mode 100644
index 000000000..42aee9940
--- /dev/null
+++ b/content/templates/tutorials/starlark/loops_slice.md
@@ -0,0 +1,141 @@
+---
+title: "Loops with Slices"
+linkTitle: "Loops with Slices"
+description: >
+  Example Starlark template with loops and slices.
+---
+
+{{% alert color="note" %}}
+We recommend reviewing [Starlark Spec](https://github.com/bazelbuild/starlark/blob/master/spec.md) before attempting to create a template.
+{{% /alert %}}
+
+## Overview
+
+From [Starlark for loops](https://github.com/google/starlark-go/blob/master/doc/spec.md#for-loops):
+
+```python
+for i in [1, 2, 3]:
+  print(i) # prints "1", "2", "3"
+```
+
+## Sample
+
+Let's take a look at ranging over a slice for a template:
+
+```python
+def main(ctx):
+  ruleset = {
+    "event": [
+      "push",
+      "pull_request"
+    ]
+  }
+
+  steps = [
+    {
+      "name": "install",
+      "image": "golang:latest",
+      "commands": [
+        "go get ./..."
+      ],
+      "pull": ctx["vars"]["pull_policy"],
+      "ruleset": ruleset,
+    }
+  ]
+
+  for image in ctx["vars"]["images"]:
+    steps.append(
+      {
+        "name": "test_%s" % image,
+        "image": image,
+        "commands": [
+          "go test ./..."
+        ],
+        "pull": ctx["vars"]["pull_policy"],
+        "ruleset": ruleset,
+      }
+    )
+
+  steps.append(
+    {
+      "name": "build",
+      "image": "golang:latest",
+      "commands": [
+        "go build"
+      ],
+      "environment": {
+        "CGO_ENABLED": "0",
+        "GOOS": "linux",
+      },
+      "pull": ctx["vars"]["pull_policy"],
+      "ruleset": ruleset,
+    }
+  )
+
+  pipeline = {
+    'version': '1',
+    'steps': steps,
+  }
+
+  return pipeline
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: sample
+    source: github.com/<org>/<repo>/path/to/file/<template>.star
+    format: starlark
+    type: github
+
+steps:
+  - name: sample
+    template:
+      name: golang
+      vars:
+        pull_policy: "always"
+        images: [ golang:latest, golang:1.13, golang:1.12s ]
+```
+
+Which means the compiled pipeline for execution on a worker is:
+
+```yaml
+version: "1"
+steps:
+  - name: sample_test_latest
+    commands:
+      - go test ./...
+    image: golang:latest
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+
+  - name: sample_test_golang:1.13
+    commands:
+      - go test ./...
+    image: golang:1.13
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+
+  - name: sample_test_golang:1.12
+    commands:
+      - go test ./...
+    image: golang:1.12
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+
+  - name: sample_build
+    commands:
+      - go build
+    environment:
+      CGO_ENABLED: '0'
+      GOOS: linux
+    image: golang:latest
+    pull: always
+    ruleset:
+      event: [ push, pull_request ]
+```
diff --git a/content/templates/tutorials/starlark/vars_platform.md b/content/templates/tutorials/starlark/vars_platform.md
new file mode 100644
index 000000000..fc1cb6629
--- /dev/null
+++ b/content/templates/tutorials/starlark/vars_platform.md
@@ -0,0 +1,73 @@
+---
+title: "Platform Vars"
+linkTitle: "Platform Vars"
+description: >
+  Example Starlark template with platform vars.
+---
+
+{{% alert color="note" %}}
+We recommend reviewing [Starlark Spec](https://github.com/bazelbuild/starlark/blob/master/spec.md) before attempting to create a template.
+{{% /alert %}}
+
+## Overview
+
+Platform variables can be referenced with the following syntax:
+
+`ctx['vela']['<resource>']['<name>']`
+
+## Examples
+
+- `ctx["vela"]["repo"]["name"]` equates to the `VELA_REPO_NAME` environment variable
+- `ctx["vela"]["build"]["number"]` equates to the `VELA_BUILD_NUMBER` environment variable
+- `ctx["vela"]["system"]["addr"]` equates to the `VELA_ADDR` environment variable
+
+## Sample
+
+Let's take a look at using a platform variable within a template:
+
+```python
+def main(ctx):
+  return {
+    'version': '1',
+    'steps': [
+      step(ctx["vela"]["repo"]["name"]),
+    ],
+  }
+
+def step(name):
+  return {
+    "name": "echo %s" % name,
+    "image": "alpine:latest",
+    'commands': [
+      "echo %s" % name
+    ]
+  }
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: sample
+    source: github.com/<org>/<repo>/path/to/file/<template>.star
+    format: starlark
+    type: github
+
+steps:
+  - name: build
+    template:
+      name: sample
+      vars:
+```
+
+Which means the compiled pipeline for execution on a worker is:
+
+```yaml
+version: 1
+steps:
+  - name: sample_echo hello-world
+    image: alpine:latest
+    commands:
+      - echo hello-world
+```
diff --git a/content/templates/tutorials/starlark/vars_template.md b/content/templates/tutorials/starlark/vars_template.md
new file mode 100644
index 000000000..a3b98b61f
--- /dev/null
+++ b/content/templates/tutorials/starlark/vars_template.md
@@ -0,0 +1,89 @@
+---
+title: "Template Vars"
+linkTitle: "Template Vars"
+description: >
+  Example Starlark template with template vars.
+---
+
+{{% alert color="note" %}}
+We recommend reviewing [Starlark Spec](https://github.com/bazelbuild/starlark/blob/master/spec.md) before attempting to create a template.
+{{% /alert %}}
+
+## Overview
+
+Template variables can be referenced with the following syntax:
+
+`ctx['vars'][<name>]`
+
+## Sample
+
+Let's take a look at using variables within a template:
+
+```python
+def main(ctx):
+  steps = [step(x, ctx["vars"]["pull_policy"], ctx["vars"]["commands"]) for x in ctx["vars"]["tags"]]
+
+  pipeline = {
+    'version': '1',
+    'steps': steps,
+  }
+
+  return pipeline
+
+def step(tag, pull_policy, commands):
+  return {
+    "name": "build %s" % tag,
+    "image": "golang:%s" % tag,
+    "pull": pull_policy,
+    'commands': commands.values(),
+  }
+```
+
+The caller of this template could look like:
+
+```yaml
+version: "1"
+templates:
+  - name: sample
+    source: github.com/<org>/<repo>/path/to/file/<template>.star
+    format: starlark
+    type: github
+
+steps:
+  - name: build
+    template:
+      name: sample
+      vars:
+        tags: [latest, "1.14", "1.15"]
+        pull_policy: always
+        commands:
+          test: "go test ./..."
+          build: "go build"
+```
+
+Which means the compiled pipeline for execution on a worker is:
+
+```yaml
+version: 1
+steps:
+  - name: sample_build latest
+    image: golang:latest
+    pull: always
+    commands:
+      - go test ./...
+      - go build
+
+  - name: sample_build 1.14
+    image: golang:1.14
+    pull: always
+    commands:
+      - go test ./...
+      - go build
+
+  - name: sample_build 1.15
+    image: golang:1.15
+    pull: always
+    commands:
+      - go test ./...
+      - go build
+```