diff --git a/learning/tour-of-beam/learning-content/go/content-info.yaml b/learning/tour-of-beam/learning-content/go/content-info.yaml
new file mode 100644
index 000000000000..8b75fa8771d2
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/content-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+sdk: Go
+content:
+  - introduction
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
new file mode 100644
index 000000000000..0a990668241e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -0,0 +1,56 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating PCollection
+
+Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
+
+There are several options:
+
+→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
+
+→ You can also read the data from a variety of external sources such as local or cloud-based files, databases, or other sources using Beam-provided I/O adapters
+
+Through the tour, most of the examples use either a `PCollection` created from in-memory data or data read from one of the cloud buckets "beam-examples" or "dataflow-samples". These buckets contain sample data sets specifically created for educational purposes.
+
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
+
+### Creating a PCollection from in-memory data
+
+You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Go Collection. You can apply Create transform directly to your Pipeline object itself.
+
+The following example code shows how to do this:
+
+```
+func main() {
+    ctx := context.Background()
+
+    // First create pipeline
+    p, s := beam.NewPipelineWithRoot()
+
+    //Now create the PCollection using list of strings
+    strings := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+
+    //Create a numerical PCollection
+    numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+
+}
+```
+
+### Playground exercise
+
+You can find the complete code of this example in the playground window you can run and experiment with.
+
+One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
new file mode 100644
index 000000000000..ef8cccb3bc19
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
@@ -0,0 +1,54 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// beam-playground:
+//   name: ParDo
+//   description: ParDo example.
+//   multifile: false
+//   context_line: 32
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+package main
+
+import (
+  "context"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+  "fmt"
+)
+
+func main() {
+  p, s := beam.NewPipelineWithRoot()
+
+  words := beam.Create(s, "Hello", "world", "it`s", "Beam")
+
+  output(s, words)
+
+  err := beamx.Run(context.Background(), p)
+  if err != nil {
+    log.Exitf(context.Background(), "Failed to execute job: %v", err)
+  }
+}
+
+func output(s beam.Scope, input beam.PCollection) {
+  beam.ParDo0(s, func(element interface{}) {
+    fmt.Println(element)
+    }, input)
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
new file mode 100644
index 000000000000..d26548d6cda3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-memory
+name: Creating in-memory PCollections
+taskName: ParDo
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
new file mode 100644
index 000000000000..418ed516f2b0
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
@@ -0,0 +1,25 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-collections
+name: Creating Collections
+content:
+- from-memory
+- reading-from-text
+- reading-from-csv
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
new file mode 100644
index 000000000000..fd3c6fd460eb
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -0,0 +1,35 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+### Read from csv file
+
+Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+
+Loading data from csv file requires some processing and consists of two main part:
+* Loading text lines using `TextIO.Read` transform
+* Parsing lines of text into tabular format
+
+### Playground exercise
+
+Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
+
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
new file mode 100644
index 000000000000..eeaedbb1ec51
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: CSV
+//   description: CSV example.
+//   multifile: false
+//   context_line: 44
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+    "strconv"
+    "strings"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/top"
+
+)
+
+func less(a, b float64) bool{
+    return a>b
+}
+
+func main() {
+    p, s := beam.NewPipelineWithRoot()
+
+    file := Read(s, "gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv")
+
+    cost := applyTransform(s, file)
+
+    fixedSizeElements := top.Largest(s,cost,10,less)
+
+    output(s, "Total cost: ", fixedSizeElements)
+
+    err := beamx.Run(context.Background(), p)
+    if err != nil {
+        log.Exitf(context.Background(), "Failed to execute job: %v", err)
+	}
+}
+
+// Read reads from fiename(s) specified by a glob string and a returns a PCollection<string>.
+func Read(s beam.Scope, glob string) beam.PCollection {
+    return textio.Read(s, glob)
+}
+
+// ApplyTransform converts to uppercase all elements in a PCollection<string>.
+func applyTransform(s beam.Scope, input beam.PCollection) beam.PCollection {
+    return beam.ParDo(s, func(line string) float64 {
+        taxi := strings.Split(strings.TrimSpace(line), ",")
+        if len(taxi) > 16 {
+            cost, _ := strconv.ParseFloat(taxi[16],64)
+            return cost
+        }
+        return 0.0
+    }, input)
+}
+
+func output(s beam.Scope, prefix string, input beam.PCollection) {
+    beam.ParDo0(s, func(elements []float64) {
+        for _, element := range elements {
+        fmt.Println(prefix,element)
+        }
+    }, input)
+}
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
new file mode 100644
index 000000000000..3d12a4dc6532
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-csv
+name: Creating PCollections from csv files
+taskName: CSV
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
new file mode 100644
index 000000000000..4968aa7d9528
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -0,0 +1,41 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Reading from text file
+
+You use one of the Beam-provided I/O adapters to read from an external source. The adapters vary in their exact usage, but all of them read from some external data source and return a `PCollection` whose elements represent the data records in that source.
+
+Each data source adapter has a Read transform; to read, you must apply that transform to the Pipeline object itself.
+
+`TextIO.Read` , for example, reads from an external text file and returns a `PCollection` whose elements are of type String. Each String represents one line from the text file. Here’s how you would apply `TextIO.Read` to your Pipeline to create a `PCollection`:
+
+```
+func main() {
+    ctx := context.Background()
+
+    // First create pipline
+    p, s := beam.NewPipelineWithRoot()
+
+    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file
+    lines :=  textio.Read(scope, 'gs://some/inputData.txt')
+
+}
+```
+
+### Playground exercise
+
+In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
+
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `top.Largest(s,lines,10,less)` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/shakespeare/kinglear.txt)
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
new file mode 100644
index 000000000000..a88249e6a0cb
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+/*
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+// beam-playground:
+//   name: TextIO
+//   description: TextIO example.
+//   multifile: false
+//   context_line: 46
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/filter"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+    "regexp"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/top"
+)
+
+var (
+    wordRE = regexp.MustCompile(`[a-zA-Z]+('[a-z])?`)
+)
+
+func less(a, b string) bool{
+    return len(a)>len(b)
+}
+
+func main() {
+    p, s := beam.NewPipelineWithRoot()
+
+    file := Read(s, "gs://apache-beam-samples/shakespeare/kinglear.txt")
+
+    lines := getLines(s, file)
+    fixedSizeLines := top.Largest(s,lines,10,less)
+    output(s, "Lines: ", fixedSizeLines)
+
+    words := getWords(s,lines)
+    fixedSizeWords := top.Largest(s,words,10,less)
+    output(s, "Words: ", fixedSizeWords)
+
+    err := beamx.Run(context.Background(), p)
+    if err != nil {
+        log.Exitf(context.Background(), "Failed to execute job: %v", err)
+    }
+}
+
+// Read reads from fiename(s) specified by a glob string and a returns a PCollection<string>.
+func Read(s beam.Scope, glob string) beam.PCollection {
+    return textio.Read(s, glob)
+}
+
+// Read text file content line by line. resulting PCollection contains elements, where each element contains a single line of text from the input file.
+func getLines(s beam.Scope, input beam.PCollection) beam.PCollection {
+    return filter.Include(s, input, func(element string) bool {
+        return element != ""
+    })
+}
+
+// getWords read text lines and split into PCollection of words.
+func getWords(s beam.Scope, input beam.PCollection) beam.PCollection {
+    return beam.ParDo(s, func(line string, emit func(string)) {
+        for _, word := range wordRE.FindAllString(line, -1) {
+            emit(word)
+        }
+    }, input)
+}
+
+func output(s beam.Scope, prefix string, input beam.PCollection) {
+    beam.ParDo0(s, func(elements []string) {
+        for _, element := range elements {
+        fmt.Println(prefix,element)
+        }
+    }, input)
+}
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
new file mode 100644
index 000000000000..396a0190f74a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-text
+name: Creating PCollections from text files
+taskName: TextIO
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
new file mode 100644
index 000000000000..19ef8ae2fd5b
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
@@ -0,0 +1,25 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: concepts
+name: Beam Concepts
+content:
+- runner-concepts
+- pipeline-concepts
+- creating-collections
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
new file mode 100644
index 000000000000..3aa6c64978cd
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -0,0 +1,36 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating a pipeline
+
+The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then using that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
+
+To use Beam, your driver program must first create an instance of the Beam SDK class Pipeline (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the Pipeline object when you create the object.
+
+```
+// beam.Init() is an initialization hook that must be called
+// near the beginning of main(), before creating a pipeline.
+beam.Init()
+
+// Create the Pipeline object and root scope.
+pipeline, scope := beam.NewPipelineWithRoot()
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with. And you can create a `pipeline`, `scope` separately, it is an alternative to `beam.NewPipelineWithRoot()`. It is convenient if manipulations are needed before creating an element.
+
+```
+pipeline := beam.NewPipeline()
+scope := p.Root()
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
new file mode 100644
index 000000000000..05e8e0af767b
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
@@ -0,0 +1,53 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// beam-playground:
+//   name: creating-pipeline
+//   description: Creating pipeline example.
+//   multifile: false
+//   context_line: 34
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+package main
+
+import (
+  "context"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/debug"
+)
+
+
+
+func main() {
+  p, s := beam.NewPipelineWithRoot()
+
+  hello := helloBeam(s)
+  debug.Print(s, hello)
+
+  err := beamx.Run(context.Background(), p)
+  if err != nil {
+    log.Exitf(context.Background(), "Failed to execute job: %v", err)
+  }
+}
+
+func helloBeam(s beam.Scope) beam.PCollection {
+  return beam.Create(s, "Hello Beam")
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..f3c47a5fe1ed
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-pipeline
+name: Creating pipelines
+taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
new file mode 100644
index 000000000000..dd46ad6e61ad
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -0,0 +1,25 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: pipeline-concepts
+name: Pipeline concepts
+content:
+- overview-pipeline
+- creating-pipeline
+- setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
new file mode 100644
index 000000000000..ce5cb7f69ff9
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
@@ -0,0 +1,43 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+### Overview
+
+To use Beam, you first need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs. It also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
+
+→ `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
+
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+→ Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
+
+→ Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
+
+→ Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..86b85b02ca47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: overview-pipeline
+name: Pipeline overview
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
new file mode 100644
index 000000000000..23781b1e5ea2
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -0,0 +1,71 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+### Setting PipelineOptions from command-line arguments
+
+Use Go flags to parse command line arguments to configure your pipeline. Flags must be parsed before `beam.Init()` is called.
+
+```
+// If beamx or Go flags are used, flags must be parsed first,
+// before beam.Init() is called.
+flag.Parse()
+```
+
+This interprets command-line arguments this follow the format:
+
+```
+--<option>=<value>
+```
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+// Use standard Go flags to define pipeline options.
+var (
+  input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
+  output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
+)
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with.
+
+You can transfer files of other extensions. For example, a csv file with taxi order data. And after making some transformations, you can write to a new csv file:
+```
+var (
+  input = flag.String("input", "gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv", "File(s) to read.")
+
+  output = flag.String("output", "output.csv", "Output file (required).")
+)
+```
+
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
new file mode 100644
index 000000000000..bb3dba69e273
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -0,0 +1,73 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// beam-playground:
+//   name: setting-pipeline
+//   description: Setting pipeline example.
+//   multifile: false
+//   context_line: 34
+//   pipeline_options: --output output.txt
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+package main
+
+import (
+  "context"
+  "flag"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+)
+
+var (
+  // By default, this example reads from a public dataset containing the text of
+  // King Lear. Set this option to choose a different input file or glob.
+  input = flag.String("input", "gs://apache-beam-samples/shakespeare/kinglear.txt", "File(s) to read.")
+
+  // Set this required option to specify where to write the output.
+  output = flag.String("output", "", "Output file (required).")
+)
+
+func main() {
+  // If beamx or Go flags are used, flags must be parsed first.
+  flag.Parse()
+
+  ctx := context.Background()
+
+  // Input validation is done as usual. Note that it must be after Init().
+  if *output == "" {
+    log.Exitf(ctx,"No output provided")
+  }
+
+  p := beam.NewPipeline()
+  s := p.Root()
+
+  // Read from option input file
+  lines := textio.Read(s, *input)
+
+  // Write to option output file
+  textio.Write(s, *output, lines)
+
+  err := beamx.Run(ctx, p)
+
+  if err != nil {
+    log.Exitf(ctx, "Failed to execute job: %v", err)
+  }
+}
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..1e5073ce8dd6
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: setting-pipeline
+name: Configuring pipeline options
+taskName: setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
new file mode 100644
index 000000000000..9aac75bdb681
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
@@ -0,0 +1,60 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Overview
+
+Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
+
+### Direct runner
+The Direct Runner executes pipelines on your machine and is designed to validate that pipelines adhere to the Apache Beam model as closely as possible. Instead of focusing on efficient pipeline execution, the Direct Runner performs additional checks to ensure that users do not rely on semantics that are not guaranteed by the model. Some of these checks include:
+
+* enforcing immutability of elements
+* enforcing encodability of elements
+* elements are processed in an arbitrary order at all points
+* serialization of user functions (DoFn, CombineFn, etc.)
+
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.In the SDK Go, the default is runner **DirectRunner**.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/direct/)
+
+#### Run example
+
+```
+$ go install github.com/apache/beam/sdks/v2/go/examples/wordcount
+$ wordcount --input <PATH_TO_INPUT_FILE> --output counts
+```
+
+### Google Cloud Dataflow runner
+
+The Google Cloud Dataflow uses the Cloud Dataflow managed service. When you run your pipeline with the Cloud Dataflow service, the runner uploads your executable code and dependencies to a Google Cloud Storage bucket and creates a Cloud Dataflow job, which executes your pipeline on managed resources in Google Cloud Platform. The Cloud Dataflow Runner and service are suitable for large scale, continuous jobs, and provide:
+* a fully managed service
+* autoscaling of the number of workers throughout the lifetime of the job
+* dynamic work rebalancing
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/dataflow/)
+
+#### Run example
+
+```
+$ go install github.com/apache/beam/sdks/v2/go/examples/wordcount
+# As part of the initial setup, for non linux users - install package unix before run
+$ go get -u golang.org/x/sys/unix
+$ wordcount --input gs://dataflow-samples/shakespeare/kinglear.txt \
+--output gs://<your-gcs-bucket>/counts \
+--runner dataflow \
+--project your-gcp-project \
+--region your-gcp-region \
+--temp_location gs://<your-gcs-bucket>/tmp/ \
+--staging_location gs://<your-gcs-bucket>/binaries/ \
+--worker_harness_container_image=apache/beam_go_sdk:latest
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/unit-info.yaml
new file mode 100644
index 000000000000..c1637f5fb6b7
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: runner-concepts
+name: Runners
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
new file mode 100644
index 000000000000..9b9d7a09827e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -0,0 +1,22 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
+The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
+You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’ button. Output is displayed in the lower right pane.
+Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
+Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/unit-info.yaml
new file mode 100644
index 000000000000..76be8c5825fd
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: guide
+name: Tour of Beam Guide
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
new file mode 100644
index 000000000000..73fbb2ff2fea
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
@@ -0,0 +1,38 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+**Pipeline** - A pipeline is a user-constructed graph of transformations that defines the desired data processing operations.
+
+**PCollection** - A PCollection is a data set or data stream. The data that a pipeline processes is part of a PCollection.
+
+**PTransform** - A PTransform (or transform) represents a data processing operation, or a step, in your pipeline. A transform is applied to zero or more PCollection objects, and produces zero or more PCollection objects.
+
+**Aggregation** - Aggregation is computing a value from multiple (1 or more) input elements.
+
+**User-defined function (UDF)** - Some Beam operations allow you to run user-defined code as a way to configure the transform.
+
+**Schema** - A schema is a language-independent type definition for a PCollection. The schema for a PCollection defines elements of that PCollection as an ordered list of named fields.
+
+**SDK** - A language-specific library that lets pipeline authors build transforms, construct their pipelines, and submit them to a runner.
+
+**Runner** - A runner runs a Beam pipeline using the capabilities of your chosen data processing engine.
+
+**Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
+
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in event time order, or to always arrive at predictable intervals.
+
+**Trigger** - A trigger determines when to aggregate the results of each window.
+
+**State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
+
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/unit-info.yaml
new file mode 100644
index 000000000000..747bcb75e743
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: terms
+name: List of Beam Terms
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/module-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/module-info.yaml
new file mode 100644
index 000000000000..78c6ae713bda
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/module-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: introduction
+name: Introduction
+complexity: BASIC
+content:
+- introduction-guide
+- introduction-concepts
+- introduction-terms
+
diff --git a/learning/tour-of-beam/learning-content/java/content-info.yaml b/learning/tour-of-beam/learning-content/java/content-info.yaml
new file mode 100644
index 000000000000..7406bb513e32
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/content-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+sdk: Java
+content:
+  - introduction
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
new file mode 100644
index 000000000000..5265259b8f4a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -0,0 +1,60 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating PCollection
+
+Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
+
+There are several options:
+
+→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
+
+→ You can also read the data from a variety of external sources such as local or cloud-based files, databases, or other sources using Beam-provided I/O adapters
+
+Through the tour, most of the examples use either a `PCollection` created from in-memory data or data read from one of the cloud buckets "beam-examples" or "dataflow-samples". These buckets contain sample data sets specifically created for educational purposes.
+
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
+
+### Creating a PCollection from in-memory data
+
+You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Java Collection. You can apply Create transform directly to your Pipeline object itself.
+
+The following example code shows how to do this:
+
+```
+public static void main(String[] args) {
+    // First create the pipeline
+    PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+    Pipeline pipeline = Pipeline.create(options);
+
+    // Now create the PCollection using list of strings
+    PCollection<String> strings =
+        pipeline.apply(
+            Create.of("To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+        );
+
+    // Create a numerical PCollection
+    PCollection<Integer> numbers =
+        pipeline.apply(
+            Create.of(1,2,3,4,5,6,7,8,9,10)
+        );
+}
+```
+
+### Playground exercise
+
+You can find the complete code of this example in the playground window you can run and experiment with.
+
+One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
new file mode 100644
index 000000000000..9ee6ea7d8e1f
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+/*
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: ParDo
+//   description: ParDo example.
+//   multifile: false
+//   context_line: 36
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Create;
+import org.apache.beam.sdk.transforms.Min;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.ParDo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+    public static void main(String[] args) {
+
+        LOG.info("Running Task");
+
+        PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+        Pipeline pipeline = Pipeline.create(options);
+
+        PCollection<String> words =
+                pipeline.apply(
+                        Create.of("To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+                );
+
+        PCollection<Integer> numbers =
+                pipeline.apply(
+                        Create.of(1,2,3,4,5,6,7,8,9,10)
+                );
+
+        words.apply("Log words", ParDo.of(new LogStrings()));
+        numbers.apply("Log numbers", ParDo.of(new LogIntegers()));
+
+
+        pipeline.run();
+    }
+
+
+    public static class LogStrings extends DoFn<String, String> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Processing word: {}", c.element());
+            c.output(c.element());
+        }
+    }
+
+    public static class LogIntegers extends DoFn<Integer, Integer> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Processing number: {}", c.element());
+            c.output(c.element());
+        }
+    }
+}
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
new file mode 100644
index 000000000000..d26548d6cda3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-memory
+name: Creating in-memory PCollections
+taskName: ParDo
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/group-info.yaml
new file mode 100644
index 000000000000..f291d762b04e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/group-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-collections
+name: Creating Collections
+content:
+- from-memory
+- reading-from-text
+- reading-from-csv
+
+
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
new file mode 100644
index 000000000000..fd3c6fd460eb
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -0,0 +1,35 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+### Read from csv file
+
+Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+
+Loading data from csv file requires some processing and consists of two main part:
+* Loading text lines using `TextIO.Read` transform
+* Parsing lines of text into tabular format
+
+### Playground exercise
+
+Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
+
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
new file mode 100644
index 000000000000..ed2e44f8ebc1
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: CSV
+//   description: CSV example.
+//   multifile: false
+//   context_line: 50
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+import java.util.Arrays;
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Count;
+import org.apache.beam.sdk.transforms.Filter;
+import org.apache.beam.sdk.transforms.FlatMapElements;
+import org.apache.beam.sdk.transforms.MapElements;
+import org.apache.beam.sdk.transforms.PTransform;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.TypeDescriptors;
+import org.apache.beam.sdk.transforms.Flatten;
+import org.apache.beam.sdk.transforms.Sample;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.ParDo;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+
+    public static void main(String[] args) {
+
+        PipelineOptions options = PipelineOptionsFactory.create();
+
+        // Create the Pipeline object with the options we defined above
+        Pipeline p = Pipeline.create(options);
+        PCollection<String> rides = p.apply(TextIO.read().from("gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv"));
+
+        PCollection<Double> rideTolalAmounts = rides.apply(ParDo.of(new ExtractTaxiRideCostFn()));
+        final PTransform<PCollection<Double>, PCollection<Iterable<Double>>> sample = Sample.fixedSizeGlobally(10);
+        PCollection<Double> rideAmounts = rideTolalAmounts.apply(sample)
+                .apply(Flatten.iterables())
+                .apply("Log amounts", ParDo.of(new LogDouble()));
+
+        p.run().waitUntilFinish();
+
+    }
+
+    private static Double tryParseTaxiRideCost(String[] inputItems) {
+        try {
+            return Double.parseDouble(tryParseString(inputItems, 16));
+        } catch (NumberFormatException | NullPointerException e) {
+            return 0.0;
+        }
+    }
+
+
+    private static String tryParseString(String[] inputItems, int index) {
+        return inputItems.length > index ? inputItems[index] : null;
+    }
+
+    static class ExtractTaxiRideCostFn extends DoFn<String, Double> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) {
+            String[] items = c.element().split(",");
+            Double totalAmount = tryParseTaxiRideCost(items);
+            c.output(totalAmount);
+        }
+    }
+
+    public static class LogDouble extends DoFn<Double, Double> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Total Amount: {}", c.element());
+            c.output(c.element());
+        }
+    }
+}
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
new file mode 100644
index 000000000000..3d12a4dc6532
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-csv
+name: Creating PCollections from csv files
+taskName: CSV
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
new file mode 100644
index 000000000000..5c4ff2651f71
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -0,0 +1,42 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Reading from text file
+
+You use one of the Beam-provided I/O adapters to read from an external source. The adapters vary in their exact usage, but all of them read from some external data source and return a `PCollection` whose elements represent the data records in that source.
+
+Each data source adapter has a Read transform; to read, you must apply that transform to the Pipeline object itself.
+
+`TextIO.Read` , for example, reads from an external text file and returns a `PCollection` whose elements are of type String. Each String represents one line from the text file. Here’s how you would apply `TextIO.Read` to your Pipeline to create a `PCollection`:
+
+```
+public static void main(String[] args) {
+    // First create the pipeline
+    PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+    Pipeline pipeline = Pipeline.create(options);
+
+    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file
+    PCollection<String> lines =
+        pipeline.apply(“King Lear”,TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt")
+);
+
+}
+```
+
+### Playground exercise
+
+In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
+
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/shakespeare/kinglear.txt)
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
new file mode 100644
index 000000000000..9e64b27339bf
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+/*
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// beam-playground:
+//   name: TextIO
+//   description: TextIO example.
+//   multifile: false
+//   context_line: 36
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+package org.apache.beam.examples;
+
+import java.util.Arrays;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Count;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.Filter;
+import org.apache.beam.sdk.transforms.Flatten;
+import org.apache.beam.sdk.transforms.FlatMapElements;
+import org.apache.beam.sdk.transforms.MapElements;
+import org.apache.beam.sdk.transforms.ParDo;
+import org.apache.beam.sdk.transforms.PTransform;
+import org.apache.beam.sdk.transforms.Sample;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.TypeDescriptors;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+
+    public static void main(String[] args) {
+
+        PipelineOptions options = PipelineOptionsFactory.create();
+
+        // Create the Pipeline object with the options we defined above
+        Pipeline p = Pipeline.create(options);
+
+        // Concept #1. Read text file content line by line. resulting PCollection contains elements, where each element
+        // contains a single line of text from the input file.
+        PCollection<String> lines = p.apply(TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt"))
+                .apply(Filter.by((String line) -> !line.isEmpty()));
+
+        // Concept #2. Output first 10 elements PCollection to the console.
+        final PTransform<PCollection<String>, PCollection<Iterable<String>>> sample = Sample.fixedSizeGlobally(10);
+
+        PCollection<String> sampleLines = lines.apply(sample)
+                .apply(Flatten.iterables())
+                .apply("Log lines", ParDo.of(new LogStrings()));
+
+
+        //Concept #3. Read text file and split into PCollection of words.
+        PCollection<String> words = p.apply(TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt"))
+                .apply(FlatMapElements.into(TypeDescriptors.strings()).via((String line) -> Arrays.asList(line.split("[^\\p{L}]+"))))
+                .apply(Filter.by((String word) -> !word.isEmpty()));
+
+        PCollection<String> sampleWords = words.apply(sample)
+                .apply(Flatten.iterables())
+                .apply("Log words", ParDo.of(new LogStrings()));
+
+        // Concept #4. Write PCollection to text file.
+        sampleWords.apply(TextIO.write().to("sample-words"));
+        p.run().waitUntilFinish();
+    }
+
+    public static class LogStrings extends DoFn<String, String> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Processing element: {}", c.element());
+            c.output(c.element());
+        }
+    }
+
+}
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
new file mode 100644
index 000000000000..396a0190f74a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-text
+name: Creating PCollections from text files
+taskName: TextIO
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
new file mode 100644
index 000000000000..95f5868d570b
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: concepts
+name: Beam Concepts
+content:
+- runner-concepts
+- pipeline-concepts
+- creating-collections
+
+
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
new file mode 100644
index 000000000000..ecaed7319d19
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -0,0 +1,36 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating a pipeline
+
+The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a `Pipeline` object, and then using that object as the basis for creating the pipeline’s data sets as `PCollection`s and its operations as `Transforms`.
+
+To use Beam, your driver program must first create an instance of the Beam SDK class `Pipeline` (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the `Pipeline` object when you create the object.
+
+```
+// Start by defining the options for the pipeline.
+PipelineOptions options = PipelineOptionsFactory.create();
+
+// Then create the pipeline.
+Pipeline p = Pipeline.create(options);
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with.
+
+When creating pipelines when writing arguments (String args[]), you can explicitly specify runner:
+
+```
+--runner=DirectRunner
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
new file mode 100644
index 000000000000..1606e99f271d
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: creating-pipeline
+//   description: Creating pipeline example.
+//   multifile: false
+//   context_line: 33
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.transforms.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+
+    public static void main(String[] args) {
+        PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+        Pipeline pipeline = Pipeline.create(options);
+
+        PCollection<String> output = createPCollection(pipeline);
+
+        output.apply("Log", ParDo.of(new LogOutput<String>()));
+
+        pipeline.run();
+    }
+
+    static PCollection<String> createPCollection(Pipeline pipeline) {
+        return pipeline.apply(Create.of("Hello Beam"));
+    }
+
+    static class LogOutput<T> extends DoFn<T, T> {
+        private String prefix;
+
+        LogOutput() {
+            this.prefix = "Processing element";
+        }
+
+        LogOutput(String prefix) {
+            this.prefix = prefix;
+        }
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info(prefix + ": {}", c.element());
+        }
+    }
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..f3c47a5fe1ed
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-pipeline
+name: Creating pipelines
+taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
new file mode 100644
index 000000000000..dd46ad6e61ad
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -0,0 +1,25 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: pipeline-concepts
+name: Pipeline concepts
+content:
+- overview-pipeline
+- creating-pipeline
+- setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
new file mode 100644
index 000000000000..6aa27fdb5b47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
@@ -0,0 +1,42 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Overview
+
+To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+
+→ `Scope`: The Go SDK has an explicit scope variable used to build a Pipeline. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is passed to PTransform functions to place them in the Pipeline that owns the Scope.
+
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+
+→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
+
+→ Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..86b85b02ca47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: overview-pipeline
+name: Pipeline overview
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
new file mode 100644
index 000000000000..66ac439ffc0e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -0,0 +1,102 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+When you run the pipeline on a runner of your choice, a copy of the PipelineOptions will be available to your code. For example, if you add a PipelineOptions parameter to a DoFn’s `@ProcessElement` method, it will be populated by the system.
+
+### Setting PipelineOptions from command-line arguments
+
+While you can configure your pipeline by creating a PipelineOptions object and setting the fields directly, the Beam SDKs include a command-line parser that you can use to set fields in PipelineOptions using command-line arguments.
+
+To read options from the command-line, construct your PipelineOptions object as demonstrated in the following example code:
+
+```
+PipelineOptions options =
+    PipelineOptionsFactory.fromArgs(args).withValidation().create();
+```
+
+This interprets command-line arguments that follow the format:
+
+```
+--<option>=<value>
+```
+
+> Appending the method .withValidation will check for required command-line arguments and validate argument values.
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+To add your own options, define an interface with getter and setter methods for each option.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+public interface MyOptions extends PipelineOptions {
+    String getInput();
+    void setInput(String input);
+
+    String getOutput();
+    void setOutput(String output);
+}
+```
+
+You set the description and default value using annotations, as follows:
+
+```
+public interface MyOptions extends PipelineOptions {
+    @Description("Input for the pipeline")
+    @Default.String("gs://my-bucket/input")
+    String getInput();
+    void setInput(String input);
+
+    @Description("Output for the pipeline")
+    @Default.String("gs://my-bucket/output")
+    String getOutput();
+    void setOutput(String output);
+}
+```
+
+It’s recommended that you register your interface with `PipelineOptionsFactory` and then pass the interface when creating the `PipelineOptions` object. When you register your interface with `PipelineOptionsFactory`, the `--help` can find your custom options interface and add it to the output of the --help command. `PipelineOptionsFactory` will also validate that your custom options are compatible with all other registered options.
+
+The following example code shows how to register your custom options interface with `PipelineOptionsFactory`:
+
+```
+PipelineOptionsFactory.register(MyOptions.class);
+MyOptions options = PipelineOptionsFactory.fromArgs(args)
+                                                .withValidation()
+                                                .as(MyOptions.class);
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with. And you can transfer files of other extensions. For example, a csv file with taxi order data. And after making some transformations, you can write to a new csv file:
+
+```
+--input=gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv --output=output.csv
+```
+
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
new file mode 100644
index 000000000000..585d53b0b80b
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: setting-pipeline
+//   description: Setting pipeline example.
+//   multifile: false
+//   pipeline_options: --output output.txt
+//   context_line: 33
+//   categories:
+//     - Quickstart
+//   complexity: BASIC
+//   tags:
+//     - hellobeam
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+import org.apache.beam.sdk.options.*;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.transforms.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+    public interface MyOptions extends PipelineOptions {
+        // Default value if [--output] equal null
+        @Description("Path of the file to read from")
+        @Default.String("gs://apache-beam-samples/shakespeare/kinglear.txt")
+        String getInputFile();
+
+        void setInputFile(String value);
+
+
+        // Set this required option to specify where to write the output.
+        @Description("Path of the file to write to")
+        @Validation.Required
+        String getOutput();
+
+        void setOutput(String value);
+    }
+
+    public static void main(String[] args) {
+        MyOptions options = PipelineOptionsFactory.fromArgs(args).withValidation().as(MyOptions.class);
+
+        readLines(options);
+    }
+
+    static void readLines(MyOptions options) {
+        Pipeline pipeline = Pipeline.create(options);
+        PCollection<String> output = pipeline.apply("ReadLines", TextIO.read().from(options.getInputFile()))
+                .apply(Filter.by((String line) -> !line.isEmpty()));
+
+        output.apply("Log", ParDo.of(new LogOutput<String>()));
+        pipeline.run().waitUntilFinish();
+    }
+
+    static class LogOutput<T> extends DoFn<T, T> {
+        private String prefix;
+
+        LogOutput() {
+            this.prefix = "Processing element";
+        }
+
+        LogOutput(String prefix) {
+            this.prefix = prefix;
+        }
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info(prefix + ": {}", c.element());
+        }
+    }
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..1e5073ce8dd6
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: setting-pipeline
+name: Configuring pipeline options
+taskName: setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
new file mode 100644
index 000000000000..cd22a1f7c079
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
@@ -0,0 +1,416 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Overview
+
+Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
+
+### Direct runner
+The Direct Runner executes pipelines on your machine and is designed to validate that pipelines adhere to the Apache Beam model as closely as possible. Instead of focusing on efficient pipeline execution, the Direct Runner performs additional checks to ensure that users do not rely on semantics that are not guaranteed by the model. Some of these checks include:
+
+* enforcing immutability of elements
+* enforcing encodability of elements
+* elements are processed in an arbitrary order at all points
+* serialization of user functions (DoFn, CombineFn, etc.)
+
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
+
+#### Specify your dependency
+
+When using Java, you must specify your dependency on the Direct Runner in your pom.xml.
+
+```
+<dependency>
+   <groupId>org.apache.beam</groupId>
+   <artifactId>beam-runners-direct-java</artifactId>
+   <version>2.41.0</version>
+   <scope>runtime</scope>
+</dependency>
+```
+
+#### Set runner
+
+In java, you need to set runner to `args` when you start the program.
+
+```
+--runner=DirectRunner
+```
+
+### Google Cloud Dataflow runner
+
+The Google Cloud Dataflow uses the Cloud Dataflow managed service. When you run your pipeline with the Cloud Dataflow service, the runner uploads your executable code and dependencies to a Google Cloud Storage bucket and creates a Cloud Dataflow job, which executes your pipeline on managed resources in Google Cloud Platform. The Cloud Dataflow Runner and service are suitable for large scale, continuous jobs, and provide:
+* a fully managed service
+* autoscaling of the number of workers throughout the lifetime of the job
+* dynamic work rebalancing
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/dataflow/)
+
+#### Run example
+
+When using Java, you must specify your dependency on the Cloud Dataflow Runner in your `pom.xml`.
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-google-cloud-dataflow-java</artifactId>
+  <version>2.42.0</version>
+  <scope>runtime</scope>
+</dependency>
+```
+
+Then, add the mainClass name in the Maven JAR plugin.
+
+```
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-jar-plugin</artifactId>
+  <version>${maven-jar-plugin.version}</version>
+  <configuration>
+    <archive>
+      <manifest>
+        <addClasspath>true</addClasspath>
+        <classpathPrefix>lib/</classpathPrefix>
+        <mainClass>YOUR_MAIN_CLASS_NAME</mainClass>
+      </manifest>
+    </archive>
+  </configuration>
+</plugin>
+```
+
+Console:
+```
+java -jar target/beam-examples-bundled-1.0.0.jar \
+  --runner=DataflowRunner \
+  --project=<YOUR_GCP_PROJECT_ID> \
+  --region=<GCP_REGION> \
+  --tempLocation=gs://<YOUR_GCS_BUCKET>/temp/
+```
+
+### Apache Flink runner
+
+The Apache Flink Runner can be used to execute Beam pipelines using Apache Flink. For execution, you can choose between a cluster execution mode (e.g. Yarn/Kubernetes/Mesos) or a local embedded execution mode which is useful for testing pipelines. The Flink Runner and Flink are suitable for large scale, continuous jobs, and provide:
+* A streaming-first runtime that supports both batch processing and data streaming programs
+* A runtime that supports very high throughput and low event latency at the same time
+* Fault-tolerance with exactly-once processing guarantees
+* Natural back-pressure in streaming programs
+* Custom memory management for efficient and robust switching between in-memory and out-of-core data processing algorithms
+* Integration with YARN and other components of the Apache Hadoop ecosystem
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/flink/)
+
+#### Run example
+
+##### Portable
+1. Starting with Beam 2.18.0, pre-built Flink Job Service Docker images are available at Docker Hub: `Flink 1.10`, `Flink 1.11`, `Flink 1.12`, `Flink 1.13`, `Flink 1.14`.
+2. Start the JobService endpoint: `docker run --net=host apache/beam_flink1.10_job_server:latest`
+3. Submit the pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService). Optionally set environment_type set to LOOPBACK. For example:
+
+```
+import apache_beam as beam
+from apache_beam.options.pipeline_options import PipelineOptions
+
+options = PipelineOptions([
+    "--runner=PortableRunner",
+    "--job_endpoint=localhost:8099",
+    "--environment_type=LOOPBACK"
+])
+with beam.Pipeline(options) as p:
+    ...
+```
+
+##### Non portable
+
+When using Java, you must specify your dependency on the Cloud Dataflow Runner in your `pom.xml`.
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-flink-1.14</artifactId>
+  <version>2.42.0</version>
+</dependency>
+```
+
+Console:
+```
+mvn exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+    -Pflink-runner \
+    -Dexec.args="--runner=FlinkRunner \
+      --inputFile=/path/to/pom.xml \
+      --output=/path/to/counts \
+      --flinkMaster=<flink master url> \
+      --filesToStage=target/word-count-beam-bundled-0.1.jar"
+```
+
+### Apache Spark runner
+
+The Apache Spark Runner can be used to execute Beam pipelines using Apache Spark. The Spark Runner can execute Spark pipelines just like a native Spark application; deploying a self-contained application for local mode, running on Spark’s Standalone RM, or using YARN or Mesos.
+
+The Spark Runner executes Beam pipelines on top of Apache Spark, providing:
+
+* Batch and streaming (and combined) pipelines.
+* The same fault-tolerance guarantees as provided by RDDs and DStreams.
+* The same security features Spark provides.
+* Built-in metrics reporting using Spark’s metrics system, which reports Beam Aggregators as well.
+* Native support for Beam side-inputs via spark’s Broadcast variables.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/spark/)
+
+#### Run example
+
+##### Non portable
+1. Start the JobService endpoint:
+    * with Docker (preferred): docker run --net=host apache/beam_spark_job_server:latest
+    * or from Beam source code: ./gradlew :runners:spark:3:job-server:runShadow
+2. Submit the Python pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService), and environment_type set to LOOPBACK. For example:
+
+Console:
+```
+mvn compile exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+     -Dexec.args="--runner=SparkRunner --inputFile=pom.xml --output=counts" -Pspark-runner
+```
+
+##### Non Portable
+
+When using Java, you must specify your dependency on the Cloud Dataflow Runner in your `pom.xml`.
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-spark-3</artifactId>
+  <version>2.42.0</version>
+</dependency>
+```
+
+And shading the application jar using the maven shade plugin:
+
+```
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-shade-plugin</artifactId>
+  <configuration>
+    <createDependencyReducedPom>false</createDependencyReducedPom>
+    <filters>
+      <filter>
+        <artifact>*:*</artifact>
+        <excludes>
+          <exclude>META-INF/*.SF</exclude>
+          <exclude>META-INF/*.DSA</exclude>
+          <exclude>META-INF/*.RSA</exclude>
+        </excludes>
+      </filter>
+    </filters>
+  </configuration>
+  <executions>
+    <execution>
+      <phase>package</phase>
+      <goals>
+        <goal>shade</goal>
+      </goals>
+      <configuration>
+        <shadedArtifactAttached>true</shadedArtifactAttached>
+        <shadedClassifierName>shaded</shadedClassifierName>
+        <transformers>
+          <transformer
+            implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+        </transformers>
+      </configuration>
+    </execution>
+  </executions>
+</plugin>
+```
+
+
+Console:
+```
+mvn compile exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+     -Dexec.args="--runner=SparkRunner --inputFile=pom.xml --output=counts" -Pspark-runner
+```
+
+### Samza runner
+
+The Apache Samza Runner can be used to execute Beam pipelines using Apache Samza. The Samza Runner executes Beam pipeline in a Samza application and can run locally. The application can further be built into a .tgz file, and deployed to a YARN cluster or Samza standalone cluster with Zookeeper.
+
+The Samza Runner and Samza are suitable for large scale, stateful streaming jobs, and provide:
+
+* First class support for local state (with RocksDB store). This allows fast state access for high frequency streaming jobs.
+* Fault-tolerance with support for incremental checkpointing of state instead of full snapshots. This enables Samza to scale to applications with very large state.
+* A fully asynchronous processing engine that makes remote calls efficient.
+* Flexible deployment model for running the applications in any hosting environment with Zookeeper.
+* Features like canaries, upgrades and rollbacks that support extremely large deployments with minimal downtime.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/samza/)
+
+#### Run example
+
+You can specify your dependency on the Samza Runner by adding the following to your `pom.xml`:
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-samza</artifactId>
+  <version>2.42.0</version>
+  <scope>runtime</scope>
+</dependency>
+
+<!-- Samza dependencies -->
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-api</artifactId>
+  <version>${samza.version}</version>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-core_2.11</artifactId>
+  <version>${samza.version}</version>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-kafka_2.11</artifactId>
+  <version>${samza.version}</version>
+  <scope>runtime</scope>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-kv_2.11</artifactId>
+  <version>${samza.version}</version>
+  <scope>runtime</scope>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-kv-rocksdb_2.11</artifactId>
+  <version>${samza.version}</version>
+  <scope>runtime</scope>
+</dependency>
+```
+
+Console:
+```
+$ mvn exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+    -Psamza-runner \
+    -Dexec.args="--runner=SamzaRunner \
+      --inputFile=/path/to/input \
+      --output=/path/to/counts"
+```
+
+### Nemo runner
+
+The Apache Nemo Runner can be used to execute Beam pipelines using Apache Nemo. The Nemo Runner can optimize Beam pipelines with the Nemo compiler through various optimization passes and execute them in a distributed fashion using the Nemo runtime. You can also deploy a self-contained application for local mode or run using resource managers like YARN or Mesos.
+
+The Nemo Runner executes Beam pipelines on top of Apache Nemo, providing:
+
+* Batch and streaming pipelines
+* Fault-tolerance
+* Integration with YARN and other components of the Apache Hadoop ecosystem
+* Support for the various optimizations provided by the Nemo optimizer
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/nemo/)
+
+#### Run example
+
+You can specify your dependency on the Samza Runner by adding the following to your `pom.xml`:
+
+```
+<dependency>
+    <groupId>org.apache.nemo</groupId>
+    <artifactId>nemo-compiler-frontend-beam</artifactId>
+    <version>${nemo.version}</version>
+</dependency>
+<dependency>
+    <groupId>org.apache.hadoop</groupId>
+    <artifactId>hadoop-common</artifactId>
+    <version>${hadoop.version}</version>
+    <exclusions>
+        <exclusion>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </exclusion>
+        <exclusion>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-log4j12</artifactId>
+        </exclusion>
+    </exclusions>
+</dependency>
+```
+
+A self-contained application might be easier to manage and allows you to fully use the functionality that Nemo provides. Simply add the dependency shown above and shade the application JAR using the Maven Shade plugin:
+
+```
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-shade-plugin</artifactId>
+  <configuration>
+    <createDependencyReducedPom>false</createDependencyReducedPom>
+    <filters>
+      <filter>
+        <artifact>*:*</artifact>
+        <excludes>
+          <exclude>META-INF/*.SF</exclude>
+          <exclude>META-INF/*.DSA</exclude>
+          <exclude>META-INF/*.RSA</exclude>
+        </excludes>
+      </filter>
+    </filters>
+  </configuration>
+  <executions>
+    <execution>
+      <phase>package</phase>
+      <goals>
+        <goal>shade</goal>
+      </goals>
+      <configuration>
+        <shadedArtifactAttached>true</shadedArtifactAttached>
+        <shadedClassifierName>shaded</shadedClassifierName>
+        <transformers>
+          <transformer
+            implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+        </transformers>
+      </configuration>
+    </execution>
+  </executions>
+</plugin>
+```
+
+Console:
+```
+$ mvn package -Pnemo-runner && java -cp target/word-count-beam-bundled-0.1.jar org.apache.beam.examples.WordCount \
+     --runner=NemoRunner --inputFile=`pwd`/pom.xml --output=counts
+```
+
+### Jet runner
+
+The Hazelcast Jet Runner can be used to execute Beam pipelines using Hazelcast Jet.
+
+The Jet Runner and Jet are suitable for large scale continuous jobs and provide:
+
+* Support for both batch (bounded) and streaming (unbounded) data sets
+* A runtime that supports very high throughput and low event latency at the same time
+* Natural back-pressure in streaming programs
+* Distributed massively parallel data processing engine with in memory storage
+
+It’s important to note that the Jet Runner is currently in an EXPERIMENTAL state and can not make use of many of the capabilities present in Jet:
+
+* Jet has full Fault Tolerance support, the Jet Runner does not; if a job fails it must be restarted
+* Internal performance of Jet is extremely high. The Runner can’t match it as of now because Beam pipeline optimization/surgery has not been fully implemented.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/jet/)
+
+#### Run example
+
+```
+$ mvn package -P jet-runner && java -cp target/word-count-beam-bundled-0.1.jar org.apache.beam.examples.WordCount \
+     --runner=JetRunner --jetLocalMode=3 --inputFile=`pwd`/pom.xml --output=counts
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/unit-info.yaml
new file mode 100644
index 000000000000..c1637f5fb6b7
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: runner-concepts
+name: Runners
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
new file mode 100644
index 000000000000..9b9d7a09827e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
@@ -0,0 +1,22 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
+The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
+You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’ button. Output is displayed in the lower right pane.
+Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
+Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/unit-info.yaml
new file mode 100644
index 000000000000..814ca3cefbfe
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: guide
+name: Tour of Beam Guide
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
new file mode 100644
index 000000000000..73fbb2ff2fea
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
@@ -0,0 +1,38 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+**Pipeline** - A pipeline is a user-constructed graph of transformations that defines the desired data processing operations.
+
+**PCollection** - A PCollection is a data set or data stream. The data that a pipeline processes is part of a PCollection.
+
+**PTransform** - A PTransform (or transform) represents a data processing operation, or a step, in your pipeline. A transform is applied to zero or more PCollection objects, and produces zero or more PCollection objects.
+
+**Aggregation** - Aggregation is computing a value from multiple (1 or more) input elements.
+
+**User-defined function (UDF)** - Some Beam operations allow you to run user-defined code as a way to configure the transform.
+
+**Schema** - A schema is a language-independent type definition for a PCollection. The schema for a PCollection defines elements of that PCollection as an ordered list of named fields.
+
+**SDK** - A language-specific library that lets pipeline authors build transforms, construct their pipelines, and submit them to a runner.
+
+**Runner** - A runner runs a Beam pipeline using the capabilities of your chosen data processing engine.
+
+**Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
+
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in event time order, or to always arrive at predictable intervals.
+
+**Trigger** - A trigger determines when to aggregate the results of each window.
+
+**State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
+
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/unit-info.yaml
new file mode 100644
index 000000000000..d18dd26929e1
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: terms
+name: List of Beam Terms
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/module-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/module-info.yaml
new file mode 100644
index 000000000000..242874ea71d6
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/module-info.yaml
@@ -0,0 +1,26 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+id: introduction
+name: Introduction
+complexity: BASIC
+content:
+- introduction-guide
+- introduction-concepts
+- introduction-terms
+
diff --git a/learning/tour-of-beam/learning-content/python/content-info.yaml b/learning/tour-of-beam/learning-content/python/content-info.yaml
new file mode 100644
index 000000000000..ed48f6ecfb7a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/content-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+sdk: Python
+content:
+  - introduction
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
new file mode 100644
index 000000000000..1eb3abd2d021
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -0,0 +1,52 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating PCollection
+
+Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
+
+There are several options:
+
+→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
+
+→ You can also read the data from a variety of external sources such as local or cloud-based files, databases, or other sources using Beam-provided I/O adapters
+
+Through the tour, most of the examples use either a `PCollection` created from in-memory data or data read from one of the cloud buckets "beam-examples" or "dataflow-samples". These buckets contain sample data sets specifically created for educational purposes.
+
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
+
+### Creating a PCollection from in-memory data
+
+You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Python Collection. You can apply Create transform directly to your Pipeline object itself.
+
+The following example code shows how to do this:
+
+```
+# First create pipeline
+with beam.Pipeline() as p:
+
+    # Create a numerical PCollection
+    (p | beam.Create(range(1, 11)))
+
+    # Now create the PCollection using list of strings
+    (p | beam.Create(['To', 'be', 'or', 'not', 'to', 'be', 'that', 'is', 'the', 'question']))
+
+```
+
+### Playground exercise
+
+You can find the complete code of this example in the playground window you can run and experiment with.
+
+One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
new file mode 100644
index 000000000000..626a765ba2ea
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
@@ -0,0 +1,53 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: ParDo
+#   description: ParDo example.
+#   multifile: false
+#   context_line: 48
+#   categories:
+#     - Quickstart
+#   complexity: BASIC
+#   tags:
+#     - hellobeam
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+        def __init__(self, prefix=''):
+            super().__init__()
+            self.prefix = prefix
+
+        def process(self, element):
+            print(self.prefix+str(element))
+
+    def __init__(self, label=None,prefix=''):
+        super().__init__(label)
+        self.prefix = prefix
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn(self.prefix))
+
+with beam.Pipeline() as p1:
+  (p1 | beam.Create(['Hello Beam','It`s introduction'])
+     | 'Log words' >> Output())
+     
+with beam.Pipeline() as p2:
+  (p2 | beam.Create(range(1, 11))
+   | 'Log numbers' >> Output())
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
new file mode 100644
index 000000000000..d26548d6cda3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-memory
+name: Creating in-memory PCollections
+taskName: ParDo
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/group-info.yaml
new file mode 100644
index 000000000000..f291d762b04e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/group-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-collections
+name: Creating Collections
+content:
+- from-memory
+- reading-from-text
+- reading-from-csv
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
new file mode 100644
index 000000000000..910a39dbce04
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -0,0 +1,34 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Read from csv file
+
+Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+
+Loading data from csv file requires some processing and consists of two main part:
+* Loading text lines using `TextIO.Read` transform
+* Parsing lines of text into tabular format
+
+### Playground exercise
+
+Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
+
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
new file mode 100644
index 000000000000..936215b21e89
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
@@ -0,0 +1,68 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: CSV
+#   description: Csv file example.
+#   multifile: false
+#   context_line: 43
+#   categories:
+#     - Quickstart
+#   complexity: BASIC
+#   tags:
+#     - hellobeam
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+        def __init__(self, prefix=''):
+            super().__init__()
+            self.prefix = prefix
+
+        def process(self, element):
+            print(self.prefix+str(element))
+
+    def __init__(self, label=None,prefix=''):
+        super().__init__(label)
+        self.prefix = prefix
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn(self.prefix))
+
+class ExtractTaxiRideCostFn(beam.DoFn):
+
+    def process(self, element):
+        line = element.split(',')
+        return tryParseTaxiRideCost(line,16)
+
+
+def tryParseTaxiRideCost(line,index):
+    if(len(line) > index):
+        yield line[index]
+    else:
+        yield 0.0
+
+with beam.Pipeline() as p:
+  lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv') \
+            | beam.ParDo(ExtractTaxiRideCostFn()) \
+            | beam.combiners.Sample.FixedSizeGlobally(10) \
+            | beam.FlatMap(lambda cost: cost) \
+            | Output(prefix = 'Taxi cost: ')
+
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
new file mode 100644
index 000000000000..3d12a4dc6532
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-csv
+name: Creating PCollections from csv files
+taskName: CSV
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
new file mode 100644
index 000000000000..f7887bab796c
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -0,0 +1,37 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Reading from text file
+
+You use one of the Beam-provided I/O adapters to read from an external source. The adapters vary in their exact usage, but all of them read from some external data source and return a `PCollection` whose elements represent the data records in that source.
+
+Each data source adapter has a Read transform; to read, you must apply that transform to the Pipeline object itself.
+
+`TextIO.Read` , for example, reads from an external text file and returns a `PCollection` whose elements are of type String. Each String represents one line from the text file. Here’s how you would apply `TextIO.Read` to your Pipeline to create a `PCollection`:
+
+```
+# First create pipline
+with beam.Pipeline() as p:
+
+    # Now create the PCollection by reading text files. Separate elements will be added for each line in the input file
+    (p | beam.io.ReadFromText('gs://some/inputData.txt'))
+
+```
+
+### Playground exercise
+
+In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
+
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the ` beam.combiners.Sample.FixedSizeGlobally(10)` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/shakespeare/kinglear.txt)
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
new file mode 100644
index 000000000000..555c1193a0bb
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
@@ -0,0 +1,63 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: TextIO
+#   description: TextIO example.
+#   multifile: false
+#   context_line: 43
+#   categories:
+#     - Quickstart
+#   complexity: BASIC
+#   tags:
+#     - hellobeam
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+        def __init__(self, prefix=''):
+            super().__init__()
+            self.prefix = prefix
+
+        def process(self, element):
+            print(self.prefix+str(element))
+
+    def __init__(self, label=None,prefix=''):
+        super().__init__(label)
+        self.prefix = prefix
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn(self.prefix))
+
+
+with beam.Pipeline() as p:
+  lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
+            | beam.Filter(lambda line: line != "")
+
+  lines | 'Log fixed lines' >> beam.combiners.Sample.FixedSizeGlobally(10) \
+    | beam.FlatMap(lambda sentence: sentence) \
+    | Output(prefix = 'Fixed first 10 lines: ')
+
+  words = p | 'Log words' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
+            | beam.FlatMap(lambda sentence: sentence.split()) \
+            | beam.Filter(lambda word: not word.isspace() or word.isalnum()) \
+            | beam.combiners.Sample.FixedSizeGlobally(10) \
+            | beam.FlatMap(lambda word: word) \
+            | 'Log output words' >> Output(prefix = 'Word: ')
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
new file mode 100644
index 000000000000..396a0190f74a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-text
+name: Creating PCollections from text files
+taskName: TextIO
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
new file mode 100644
index 000000000000..95f5868d570b
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: concepts
+name: Beam Concepts
+content:
+- runner-concepts
+- pipeline-concepts
+- creating-collections
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
new file mode 100644
index 000000000000..a836c30ae6f3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -0,0 +1,46 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating a pipeline
+
+The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then use that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
+
+To use Beam, your driver program must first create an instance of the Beam SDK class Pipeline (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the Pipeline object when you create the object.
+
+```
+import apache_beam as beam
+
+with beam.Pipeline() as pipeline:
+  pass  # build your pipeline here
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with.
+
+When creating pipelines, you can give an argument with explicitly specified parameters:
+
+```
+beam_options = PipelineOptions(
+    runner='DataflowRunner',
+    project='my-project-id',
+    job_name='unique-job-name',
+    temp_location='gs://my-bucket/temp',
+)
+```
+
+Creation based on option:
+
+```
+pipeline = beam.Pipeline(options=beam_options)
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
new file mode 100644
index 000000000000..f090fc8968c0
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
@@ -0,0 +1,43 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: creating-pipeline
+#   description: Creating pipeline example.
+#   multifile: false
+#   context_line: 35
+#   categories:
+#     - Quickstart
+#   complexity: BASIC
+#   tags:
+#     - hellobeam
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+
+        def process(self, element):
+            print(element)
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn())
+
+with beam.Pipeline() as p:
+  (p | beam.Create(['Hello Beam'])
+   | Output())
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..f3c47a5fe1ed
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-pipeline
+name: Creating pipelines
+taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
new file mode 100644
index 000000000000..dd46ad6e61ad
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -0,0 +1,25 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: pipeline-concepts
+name: Pipeline concepts
+content:
+- overview-pipeline
+- creating-pipeline
+- setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
new file mode 100644
index 000000000000..2d51021e56ff
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
@@ -0,0 +1,40 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Overview
+
+To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program then defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+
+→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
+
+→ Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects that you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..86b85b02ca47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: overview-pipeline
+name: Pipeline overview
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
new file mode 100644
index 000000000000..6c8217dbf535
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -0,0 +1,88 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+### Setting PipelineOptions from command-line arguments
+
+While you can configure your pipeline by creating a `PipelineOptions` object and setting the fields directly, the Beam SDKs include a command-line parser that you can also use to set fields in `PipelineOptions` using command-line arguments.
+
+To read options from the command-line, construct your `PipelineOptions` object as demonstrated in the following example code:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+beam_options = PipelineOptions()
+```
+
+This interprets command-line arguments that follow this format:
+
+```
+--<option>=<value>
+```
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+class MyOptions(PipelineOptions):
+  @classmethod
+  def _add_argparse_args(cls, parser):
+    parser.add_argument('--input')
+    parser.add_argument('--output')
+```
+
+You set the description and default value using annotations, as follows:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+class MyOptions(PipelineOptions):
+  @classmethod
+  def _add_argparse_args(cls, parser):
+    parser.add_argument(
+        '--input',
+        default='gs://dataflow-samples/shakespeare/kinglear.txt',
+        help='The file path for the input text to process.')
+    parser.add_argument(
+        '--output', required=True, help='The path prefix for output files.')
+```
+
+For Python, you can also simply parse your custom options with argparse; there is no need to create a separate PipelineOptions subclass.
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with. And you can transfer files of other extensions. For example, a csv file with taxi order data. And after making some transformations, you can write to a new csv file:
+
+```
+--input=gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv --output=output.csv
+```
+
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
new file mode 100644
index 000000000000..91ce88c6fa5e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -0,0 +1,88 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: setting-pipeline
+#   description: Setting pipeline example.
+#   multifile: false
+#   context_line: 35
+#   pipeline_options: --output output.txt
+#   categories:
+#     - Quickstart
+#   context_line: 47
+#   complexity: BASIC
+#   tags:
+#     - hellobeam
+
+import argparse
+import logging
+import re
+
+import apache_beam as beam
+
+from apache_beam.io import ReadFromText
+from apache_beam.io import WriteToText
+from apache_beam.options.pipeline_options import PipelineOptions
+from apache_beam.options.pipeline_options import SetupOptions
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+
+        def process(self, element):
+            print(element)
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn())
+
+def main(argv=None, save_main_session=True):
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--input',
+        dest='input',
+        default='gs://dataflow-samples/shakespeare/kinglear.txt',
+        help='Input file to process.')
+    parser.add_argument(
+        '--output',
+        dest='output',
+        required=True,
+        help='Output file to write results to.')
+    known_args, pipeline_args = parser.parse_known_args(argv)
+
+    # We use the save_main_session option because one or more DoFn's in this
+    # workflow rely on global context (e.g., a module imported at module level).
+    pipeline_options = PipelineOptions(pipeline_args)
+    pipeline_options.view_as(SetupOptions).save_main_session = save_main_session
+
+    with beam.Pipeline(options=pipeline_options) as p:
+
+    # Read the text file[pattern] into a PCollection.
+    lines = p | 'Read' >> ReadFromText(known_args.input) \
+            | beam.Filter(lambda line: line != "")
+
+    # Write the output using a "Write" transform that has side effects.
+    # pylint: disable=expression-not-assigned
+    output = lines | 'Write' >> WriteToText(known_args.output)
+
+
+    result = p.run()
+    result.wait_until_finish()
+
+
+if __name__ == '__main__':
+    logging.getLogger().setLevel(logging.INFO)
+    main()
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..1e5073ce8dd6
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: setting-pipeline
+name: Configuring pipeline options
+taskName: setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
new file mode 100644
index 000000000000..9a0ea4e487df
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
@@ -0,0 +1,127 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Overview
+
+Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
+
+### Direct runner
+The Direct Runner executes pipelines on your machine and is designed to validate that pipelines adhere to the Apache Beam model as closely as possible. Instead of focusing on efficient pipeline execution, the Direct Runner performs additional checks to ensure that users do not rely on semantics that are not guaranteed by the model. Some of these checks include:
+
+* enforcing immutability of elements
+* enforcing encodability of elements
+* elements are processed in an arbitrary order at all points
+* serialization of user functions (DoFn, CombineFn, etc.)
+
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.In the SDK Python, the default is runner **DirectRunner**.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/direct/)
+
+#### Run example
+
+```
+python -m apache_beam.examples.wordcount --input YOUR_INPUT_FILE --output counts
+```
+
+### Google Cloud Dataflow runner
+
+The Google Cloud Dataflow uses the Cloud Dataflow managed service. When you run your pipeline with the Cloud Dataflow service, the runner uploads your executable code and dependencies to a Google Cloud Storage bucket and creates a Cloud Dataflow job, which executes your pipeline on managed resources in Google Cloud Platform. The Cloud Dataflow Runner and service are suitable for large scale, continuous jobs, and provide:
+* a fully managed service
+* autoscaling of the number of workers throughout the lifetime of the job
+* dynamic work rebalancing
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/dataflow/)
+
+#### Run example
+
+```
+# As part of the initial setup, install Google Cloud Platform specific extra components.
+pip install apache-beam[gcp]
+python -m apache_beam.examples.wordcount --input gs://dataflow-samples/shakespeare/kinglear.txt \
+                                         --output gs://YOUR_GCS_BUCKET/counts \
+                                         --runner DataflowRunner \
+                                         --project YOUR_GCP_PROJECT \
+                                         --region YOUR_GCP_REGION \
+                                         --temp_location gs://YOUR_GCS_BUCKET/tmp/
+```
+
+### Apache Flink runner
+
+The Apache Flink Runner can be used to execute Beam pipelines using Apache Flink. For execution, you can choose between a cluster execution mode (e.g. Yarn/Kubernetes/Mesos) or a local embedded execution mode which is useful for testing pipelines. The Flink Runner and Flink are suitable for large scale, continuous jobs, and provide:
+  * A streaming-first runtime that supports both batch processing and data streaming programs
+  * A runtime that supports very high throughput and low event latency at the same time
+  * Fault-tolerance with exactly-once processing guarantees
+  * Natural back-pressure in streaming programs
+  * Custom memory management for efficient and robust switching between in-memory and out-of-core data processing algorithms
+  * Integration with YARN and other components of the Apache Hadoop ecosystem
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/flink/)
+
+#### Run example
+
+1. Starting with Beam 2.18.0, pre-built Flink Job Service Docker images are available at Docker Hub: `Flink 1.10`, `Flink 1.11`, `Flink 1.12`, `Flink 1.13`, `Flink 1.14`.
+2. Start the JobService endpoint: `docker run --net=host apache/beam_flink1.10_job_server:latest`
+3. Submit the pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService). Optionally set environment_type set to LOOPBACK. For example:
+
+```
+import apache_beam as beam
+from apache_beam.options.pipeline_options import PipelineOptions
+
+options = PipelineOptions([
+    "--runner=PortableRunner",
+    "--job_endpoint=localhost:8099",
+    "--environment_type=LOOPBACK"
+])
+with beam.Pipeline(options) as p:
+    ...
+```
+
+### Apache Spark runner
+
+The Apache Spark Runner can be used to execute Beam pipelines using Apache Spark. The Spark Runner can execute Spark pipelines just like a native Spark application; deploying a self-contained application for local mode, running on Spark’s Standalone RM, or using YARN or Mesos.
+
+The Spark Runner executes Beam pipelines on top of Apache Spark, providing:
+
+* Batch and streaming (and combined) pipelines.
+* The same fault-tolerance guarantees as provided by RDDs and DStreams.
+* The same security features Spark provides.
+* Built-in metrics reporting using Spark’s metrics system, which reports Beam Aggregators as well.
+* Native support for Beam side-inputs via spark’s Broadcast variables.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/spark/)
+
+#### Run example
+
+1. Start the JobService endpoint:
+   * with Docker (preferred): docker run --net=host apache/beam_spark_job_server:latest
+   * or from Beam source code: ./gradlew :runners:spark:3:job-server:runShadow
+2. Submit the Python pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService), and environment_type set to LOOPBACK. For example:
+```
+import apache_beam as beam
+from apache_beam.options.pipeline_options import PipelineOptions
+
+options = PipelineOptions([
+    "--runner=PortableRunner",
+    "--job_endpoint=localhost:8099",
+    "--environment_type=LOOPBACK"
+])
+with beam.Pipeline(options) as p:
+    ...
+```
+
+Console:
+```
+python -m apache_beam.examples.wordcount --input /path/to/inputfile \
+                                         --output /path/to/write/counts \
+                                         --runner SparkRunner
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/unit-info.yaml
new file mode 100644
index 000000000000..c1637f5fb6b7
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: runner-concepts
+name: Runners
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
new file mode 100644
index 000000000000..9b9d7a09827e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
@@ -0,0 +1,22 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
+The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
+You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’ button. Output is displayed in the lower right pane.
+Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
+Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/unit-info.yaml
new file mode 100644
index 000000000000..814ca3cefbfe
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: guide
+name: Tour of Beam Guide
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
new file mode 100644
index 000000000000..73fbb2ff2fea
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
@@ -0,0 +1,38 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+**Pipeline** - A pipeline is a user-constructed graph of transformations that defines the desired data processing operations.
+
+**PCollection** - A PCollection is a data set or data stream. The data that a pipeline processes is part of a PCollection.
+
+**PTransform** - A PTransform (or transform) represents a data processing operation, or a step, in your pipeline. A transform is applied to zero or more PCollection objects, and produces zero or more PCollection objects.
+
+**Aggregation** - Aggregation is computing a value from multiple (1 or more) input elements.
+
+**User-defined function (UDF)** - Some Beam operations allow you to run user-defined code as a way to configure the transform.
+
+**Schema** - A schema is a language-independent type definition for a PCollection. The schema for a PCollection defines elements of that PCollection as an ordered list of named fields.
+
+**SDK** - A language-specific library that lets pipeline authors build transforms, construct their pipelines, and submit them to a runner.
+
+**Runner** - A runner runs a Beam pipeline using the capabilities of your chosen data processing engine.
+
+**Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
+
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in event time order, or to always arrive at predictable intervals.
+
+**Trigger** - A trigger determines when to aggregate the results of each window.
+
+**State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
+
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/unit-info.yaml
new file mode 100644
index 000000000000..d18dd26929e1
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: terms
+name: List of Beam Terms
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/module-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/module-info.yaml
new file mode 100644
index 000000000000..78c6ae713bda
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/module-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: introduction
+name: Introduction
+complexity: BASIC
+content:
+- introduction-guide
+- introduction-concepts
+- introduction-terms
+