There may be cases where we, depending on the input, want to give out different answers. For cases like this, it's important to know how to branch at the beginning of a flow. In this case we want edit previously created flow [User asks about coffees we offer](/getting-started/your-first-flow#create-your-first-flow) to recognize coffee types when mentioned by the user.

> **User:** What kinds of coffees do you serve?  
> **Bot:** We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.
> 
> **User:** Do you serve brewed coffee?  
> **Bot:** Yes, we do indeed serve brewed coffee in our stores!

Here you'll learn how to add a branch at the beginning of your flow and to specify different paths depending on what the user said:

*   if the user asks about coffee types we serve,
*   if the user asks if we serve a specific coffee type,

These are the steps you'll need to take:

* Extend the flow structure:
* Add a junction, and set it to be start-node
* Add one new output node.
* Link the junction to the output nodes
* Populate the output and transition for the coffee type response

The final version of the flow will look like this:  
![final flow](//images.ctfassets.net/2vbtnveccz5s/27viWmjfSaqBdCt4on8Xv0/f81950719f7ee8c2caa3c3912ae93b7d/final_flow.png)

## Open the flow in edit mode

First, you should open or [create](/getting-started/your-first-flow#create-your-first-flow) the 'User asks about coffees we offer' flow in edit mode:

1.  Select the flow 'User asks about coffees we offer' located inside the 'Flows' folder.
2.  Click 'Edit' in the ribbon. The flow will open in a new window.

## Create a new variable

As a first step we need to create a new [flow variable](/studio/flows/concepts/variables#create-a-flow-variable) that will store the coffee type the user mentions.

1. In the flows's main window, move to the 'FLOW' tab, and select 'Variables'.
2.  Add a variable and name it `mentionedCoffee`.
3.  Put `""` in the 'Evaluation Script' field. This initializes the variable with the empty string.

![1-add flow var](//videos.ctfassets.net/2vbtnveccz5s/Gx3pXYjU2JtdAFmN5rgYW/5193f462d0c5ffd531eaa2e36a1e4dd0/1-add_flow_var.mp4)

## Add an After Match to the Intent Trigger

In order to store the coffee type we need to add a After Match to the Intent Trigger. This will take the coffee type from our previously created [entity](/getting-started/create-custom-entities#create-a-coffees-served-entity) and store it inside the flow variable 'mentionedCoffee'.

1. Go back to the flow editor page and select the trigger. This will open the trigger configuration panel to the right.
2. In the configuration panel, go to 'After Match', click 'Add', and click on 'Entity'.
3. Paste in `COFFEES_SERVED` and hit 'Enter' on your keyboard.
4. Click the 'Add Mapping' button.
5. The 'Source' field denotes the value of the NLU variable of the entity 'COFFEES_SERVED' that we want to store. Select 'coffeeType' from the dropdown menu. 
6. The 'Target' field denotes the name of the variable where the extracted value is to be stored. Select 'mentionedCoffee' from the dropdown menu. 

![2-add after match](//videos.ctfassets.net/2vbtnveccz5s/7o3E2rP6Ny7JmIBtIwOAs2/f05c6b7525dce25f8d8754ff5110a137/2-add_after_match.mp4)

## Extend the flow structure

Follow these steps to re-draw the structure of the flow:

1. Add a junction by clicking on the Plus icon above the output node.
2. Hover over 'Continue With' and select a 'Junction'.  
3. Select the Plus icon under the newly created Junction, followed up with 'Split Path' and 'Transaction'.

![3-extend flow structure](//videos.ctfassets.net/2vbtnveccz5s/6vghe5STDlt0covcU5fB4k/4c9b918ce3903c984f36857f1d2efe1d/3-extend_flow_structure.mp4)

## Populate the new output and transition to recognize Coffee types
We will add a different route for when the user mentions their coffee type:

1. Select the new output node, name it: `We serve the coffee type!` and add the following answer text: `Yes, we do indeed serve ${mentionedCoffee}!`.
2. Now we need to make sure this answer is only given when the user is asking for coffee types we serve. Select the transition and name it `Coffee type mentioned and served`.
3. Add a Match for 'Flow Variable'.
4. From the dropdown, make sure 'mentionedCoffee' is selected (it will be chosen by default).
5. Make sure 'Get Input before continuing' is unselected.
6. This transition should be tested first. You can change its order in the 'Triggering' panel: change it to __1__. Notice how the output nodes change place once the ordering is changed.
7. Hit 'Save'.

![4-populate new output and transition](//videos.ctfassets.net/2vbtnveccz5s/5IKQKDpsBOmMUtP1wkcwFt/9dafe63e6683de716e04f73bf8654573/4-populate_new_output_and_transition.mp4)

## Try it out!

Now go ahead, open the 'Tryout' panel and give it a go!

> **User:** What kinds of coffees do you serve?  
> **Bot:** We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.
> 
> **User:** Do you serve brewed coffee?  
> **Bot:** Yes, we do indeed serve brewed coffee in our stores!


Build - Branch at the beginning of a flow

Branch at the beginning of a flow

Scripts can be included in flows too. Let's create a very basic flow that contains a script.

The flow we will create will suggest a random coffee drink, like so:

> **User:** Suggest a drink!  
> **Bot:** Well, you're putting me on the spot here. I'd go for a flat white!

To achieve this, the we need to create a flow that contains the following elements:
* A Class Match.
* A Script that randomly chooses a coffee type.
* A flow variable to store the value chosen by the script.
* An output that will display the value of the variable.

The final flow will look like this:

![final flow](//images.ctfassets.net/2vbtnveccz5s/22ce4KaMo9QyQ6NEHMIYrQ/fe84c8199a6bb14ce6f1e2a56f368bc7/final_flow.png)

Let's get started.

## Create a new flow and populate the trigger

1. Create a new flow and call it `User wants bot to suggest a coffee`.
2. Locate the trigger give it a name like `Suggest a drink!`. (Visual instructions of how to create a flow and populate the trigger can be found [here](/getting-started/your-first-flow#create-your-first-flow).)
3. Add the following example inputs:   
```example-inputs
Recommend a beverage
Suggest a drink
Which coffee would do you advise?
What coffee should I get?
Can you recommend me a coffee
Recommend a coffee.
Which brew should I drink?
Tell me, what coffee should I buy?
Could you decide which coffee I should get
I want a recommendation for a coffee
Can you suggest me a drink?
Which coffee should I get
Which coffee would you recommend me?
```
4. Click on the Plus icon below the trigger, followed up with 'Match' and the 'Generate' button, this will automatically generate a Class Match.

![1-create flow](//videos.ctfassets.net/2vbtnveccz5s/1V2GvNEx2wPcKaq1oKQE1h/eda49cbe1d024a8e7d4067337998cbeb/1-create_flow.mp4)

## Add a Script node
It is now time to create a script to be used. 

1.  Select the Plus icon above the output node.
2.  Hover over 'Continue with' and select 'Script'. 
3.  Give your script node a name that explains what the script does, like `Pick a drink`.

![2-add script node](//videos.ctfassets.net/2vbtnveccz5s/1C6t3PLsQd4bHprCVuGj4T/1113f120fc1cc64b32d347ff85cdb094/2-add_script_node.mp4)

!!! It is possible to replace the Script Node with a [Script Data Action](/getting-started/data-actions#data-actions-on-a-script) inside the trigger.

### Populate the script
We have added the script node, but it is still empty. Now we'll need to add the script that picks a random coffee type to suggest to the user. 

1. Paste the following code in your script panel:
```groovy
// define a list with coffee drinks to suggest
def coffeesToSuggest = ['cappuccino','flat white','macchiato']

// randomly choose a number 0, 1 or 2
def number = new Random().nextInt(3) 

// use the number to pick a coffee from the list
coffeeSuggestion = coffeesToSuggest[number]
```

!!! Scripts in Teneo are written in [Groovy](http://groovy-lang.org/index.html?target=_blank). You can find more details about Groovy and scripts in Teneo in the [Scripting](/article/build#scripting) section.

As you can see in the script code above the first two variables (__coffeesToSuggest__ and __number__) are preceded by __def__ which means they are [local variables](/article/build/flows/concepts/variables#local-variables) that are only available inside the script code. They will be forgotten immediately after the script is executed, in this case, this will happen when Teneo moves on to the output node. However, we want the outcome of the script (the coffee chosen by the script node) to be available outside of the script so we can use it in our output text. So we will need to store the value in a flow variable that we can use later on.

The last line of the script assumes a variable called __coffeeSuggestion__ exists in which the chosen coffee drink can be stored. This is determined by the fact that __coffeeSuggestion__ is not defined by preceding it with __def__. However, we don't have a flow variable called coffeeSuggestion yet, so let's add it.

![3-populate script node](//videos.ctfassets.net/2vbtnveccz5s/2WWzXpqhq2xLLo8hHRWTKM/5a959922fc767ceae4515f025fb96b9f/3-populate_script_node.mp4)

## Add a flow variable
To add a flow variable, proceed as follows:

1. Go to the Flow tab and click on Variables in the menu.
2. Add a new variable and name it `coffeeSuggestion`.
4. We want to initialize this variable as an empty string, so in the text box below add `""`.
5. Click on the back arrow in the menu to return to the main flow editor.  
![4-add variable](//videos.ctfassets.net/2vbtnveccz5s/7IZGkeUwakrxSlQSomdhnk/566bd9a652f60b2c43e47860b40056d6/4-add_variable.mp4)

You can click on the Variable icon again to minimize it.

## Add answers to the output

The user is full of anticipation so let's provide the answer. Add the following answer texts to the output node:

1. Finally, name your output node `Here is your suggestion!`.
2. Paste in the following answers:
*   `Well, you're putting me on the spot here. I'd go for a ${coffeeSuggestion}!`
*   `Now that you're asking, I'd suggest a ${coffeeSuggestion}!`
*   `Easy choice, a ${coffeeSuggestion} of course!`
3. Hit 'Save'.

![5-populate output](//videos.ctfassets.net/2vbtnveccz5s/2vslKtvYPdsywr8mbY2B0z/537b313cc424cc6c379f09fa71ec6c30/5-populate_output.mp4)

As you can see we have used the flow variable __coffeeSuggestion__ in our answers. This placeholder will be replaced by the value picked in the script node.  

## Try it out

That's it! Save your flow and give it a try in Tryout by pasting the following line: `Suggest a drink!`

> **User:** Suggest a drink!  
> **Bot:** Now that you're asking, I'd suggest a flat white!

## Extra challenge for the brave

If you're up for an extra challenge: often there are multiple ways to design a flow. In this case, for example, you can also model this flow with 3 separate output nodes (for each coffee type suggested). Can you figure out what the design of the flow would be when taking that approach? Hint: transitions can contain script conditions too!

Build - Add a script to your flow

Add a script to your flow

Some flows may be re-used as parts of other flows. In Teneo, you can use Sub-Flows to do so. For example, requesting the user's email address can be implemented as a Sub-Flow that can then be used in larger flows. In the following, we will build both the Sub-Flow and a flow that makes use of it.

This is how a conversation should look:

> **User**: I'd like to subscribe to your newsletter  
> **Bot**: I'm happy to add you as a recipient of our free newsletter. Please enter your email address.  
> 
> **User**: teneo@example.com  
> **Bot**: I have your email as teneo@example.com. Is that correct?  
> 
> **User**: no  
> **Bot**: Please enter your email address.  
> 
> **User**: teneo@example.com  
> **Bot**: Is your email address teneo@example.com correct? Please confirm.  
> 
> **User**: yes  
> **Bot**: OK, thank you! I'm adding your address teneo@example.com to our mailing list. You will receive a confirmation mail shortly.  

We will implement the conversation in two steps:

1.  Build the Sub-Flow.
2.  Build the main flow.

## Build the Sub-Flow

Our Sub-Flow to retrieve the user's email will ask the user to enter an email address, confirm with the user that the email was correct, and if correct, return the email. If not correct, the user will be re-prompted. This continues until a correct email was entered. The final Sub-flow will look as follows:  

![final subflow](//images.ctfassets.net/2vbtnveccz5s/2ecQV6TAZvvFoVZnfua4Ro/ae11609a64d9a647fd7b2ae85112285d/final_subflow.png)

### Create a Sub-Flow

First we will create a new Sub-Flow.

1. You can create a new Sub-Flow by clicking on the dropdown menu below 'Flow' and call it `Get email address`.
2.  In the 'Flow' tab, go to 'Variables', [Add a flow variable](/getting-started/build-a-slot-filling-flow#create-a-flow-variable) called `email` and initialize it to empty string `""`.
3.  Click the arrow to return to the 'Home' tab.

![1-create sub flow](//videos.ctfassets.net/2vbtnveccz5s/3s3S6zO1GmS0MJEywCjHje/47a173650acd186bda6668dd8c815ab4/1-create_sub_flow.mp4)

### Add a prompt for e-mail
1.  Select the output node and name it `Prompt for email`.
2.  Give it the output `Please enter your email address.`
3.  Add a new output node to follow it by clicking the Plus icon followed by 'Continue with' and 'Transaction'.
4.  Select the new transition and call it `Email entered`.
5. Make sure it is set to 'Get input before continuing'.
6. With the transition in the flow still marked, navigate to the Match section and a Match for 'TLML Syntax'.
7. Add the Syntax Condition `%EMAIL_ADDRESS.SCRIPT^{email=_USED_WORDS}`.

![2-add prompt for email](//videos.ctfassets.net/2vbtnveccz5s/28yF5z7bWetxfnP4QKcLRS/379bfe500f6df6f21e444d303b39424c/2-add_prompt_for_email.mp4)

### Set up the Sub-Flow to re-prompt

1. Name the output node `Confirm email` and give it an answer `I have your email as ${email}, is that correct?`.   
2. Select the 'Confirm email' output node and using the mousekey, drag and drop a transition back to the output 'Prompt for email'.   
3. Make sure the transition is set to 'Get input before continuing'.   
4. Call the transition `Re-try` and add the following examples:
```example-inputs
no
nope
nah
```
5. Finally, add a Match by clicking on the 'Generate' button to automatically generate a Match requirement based on the Intent examples specification. In this case the language object __NO.PHR__. This will send your flow back to the beginning if the email stored is wrong.

![3-set up for reprompt](//videos.ctfassets.net/2vbtnveccz5s/1Qw8lp6kgw3OPhtw9zJCdE/461007bd25b33690c1b6d6dce4e90ffb/3-set_up_for_reprompt.mp4)

### Set up a positive confirmation of the email

1. Click on the Plus icon above the 'Re-Try' Transition, followed up with 'Split Path' and 'Transaction'.
2. Select the Output node and name it `Email confirmed`. 
3. Add the following answer: `Ok, thank you!`
4. Select the new transition and make sure it is set to 'Gets input before continuing'.    
5. Call the transition `Confirmed` and add the following examples:
	```example-inputs
	yeah
	yup
	yes
	```
6. Finally, generate a Match. Click on the 'Generate' button under the 'Match' section to automatically generate a Match requirment based on the Intent example specification. In this case the language object __YES.PHR__. This will let you proceed if the email stored is correct.
7. Click save.  

![4-positive confirmation](//videos.ctfassets.net/2vbtnveccz5s/iMCuXAbdVZYPeGXu2cwvQ/cc3a55e4108736705910cc84dba4d985/4-positive_confirmation.mp4)

That's it! We can now use this sub-flow that requests the user's email address in as many other flows as we want. In the next section, we will show you how exactly to do that.

## Build the main flow

At this point, we have a Sub-Flow that is not being used anywhere. Since it doesn't have a trigger, Teneo will never select it. In this section, we will build a flow to trigger if users request to be added to the Longberry Baristas mailing list. Later this flow will make use of the Sub-Flow 'Get email address' that we created above. But for now, we will just build the question and answer. We'll add the Sub-Flow link later.

### Create the new flow

1. Create a flow and name it `User wants to subscribe to the mailing list`.
2. In the 'Flow' tab under 'Variables', add a flow variable called `email` and initialize it to empty string `""`.
3. Click the arrow to return to the home page.
4. Select the trigger, call it `Subscribe to the mailing list` and add the following positive Intent examples:
	```example-inputs
    Can i get your newsletter?
    How can i subscribe to the newsletter?
    How to get on your mailing list?
    I want to subscribe to your mailing list
    I'd like to subscribe to the newsletter
    Please add me to your mailing list
    Please put me on the mailing list
	```
5. Click on the 'Generate' button in the Match section to automatically generate the best Match based on the example specification.
6. Call the output node `Happy to add you to our mailing list`.    
7. Select the output node and add an answer `I would be happy to add you to our mailing list to receive our free newsletter.`.

![5-create main flow](//videos.ctfassets.net/2vbtnveccz5s/1nbym64Y14jbJ3BTfkaivT/fbb27eea937724b19620e9454929794c/5-create_main_flow.mp4)

### Add a call to the Sub-Flow

Now we want to pass control to the sub-flow and let it do all the work of prompting the user for an email address.

1. Click on the Plus icon below the output followed by 'Continue With' and 'Flow Link'.
2. Name the transition `Call Sub-flow` and make sure 'Get input before continuing' is unchecked.
3.  Select the 'Flow' node and call it `Get email address`.
4.  With the 'Get email address' node selected, make sure the sidebar area 'Flow Link' is visible. Click 'Browse' and select our Sub-flow 'Get email address' inside the 'Flows' folder.
5.  Retrieve the email address from the sub-flow: in the section 'From', where you see 'Get the value back', select __email__ from the dropdown list.

![6-call sub flow](//videos.ctfassets.net/2vbtnveccz5s/5Xz4Um1KqynwkOjKPgeRhl/fe8b2656147c48e4ecc2a51efea8f42f/6-call_sub_flow.mp4)

### Finish the flow

1.  Select the Plus icon below the 'Flow' node and add a new output node by hovering over 'Continue With', followed by 'Transaction Element Output'.
2. Name the transition `Return from Sub-flow` and make sure 'Get input before continuing' is unchecked.
3. Call the output node `Confirmation`.
4. Lastly, give the output an answer `I'm adding your address ${email} to our mailing list. You should receive a confirmation mail shortly.`.
5.  Hit 'Save'.

![7-finish the flow](//videos.ctfassets.net/2vbtnveccz5s/423maGqIyCcyuwT303T2Dv/e1d1c208b270686930e53bed9555f1b2/7-finish_the_flow.mp4)

That's it! You may now give it a go in Tryout and replicate the conversation below. Note that the answer parts from the sub-flow are *italic* for illustrative purposes. In practice, they will not be distinguishable from the answers of the main flow:

> **User**: I want to subscribe to your newsletter!  
> **Bot**: I'm happy to add you to receive our completely free newsletter. *Please enter your email address.*  
> 
> **User**: teneo@example.com  
> **Bot**: *I have your email as teneo@example.com, is that correct?*  
> 
> **User**: Yes.  
> **Bot**: *OK, thank you!* I'm adding your address teneo@example.com to our mailing list. You should receive a confirmation mail shortly.

!!! Note that if the name of the Sub-flow should change at some point, all existing connections between main flows and this Sub-flow will automatically be updated by Teneo.

Build - Use a Flow link

Use a Sub-Flow

In Teneo, we can use different kinds of [Match](/studio/flows/concepts/triggers#match-requirements) requirements in our flow triggers. We have already shown some [examples](/getting-started/build-a-slot-filling-flow) of different ones. Now we will show you how to create a conditional trigger.

Both triggers with TLML Syntax Match and those with Class Match can be built automatically from testing examples. The difference between the two is that with conditions, we have the ability to hand-tailor intent trigger using Teneo's [condition syntax](/studio/reference/condition-syntax) to either cover a broad use case or a very specific set of words and sentences.

We will now build a new flow for people that are interested in joining the Longberry Baristas' loyalty program, which will have a trigger with a [TLML Syntax Match](/studio/flows/concepts/triggers#condition) and allow dialogs like the following:

> **User:** How much does it cost to join the loyalty program?  
> **Bot:** You can join the loyalty program for free! Just ask your local barista for a club card and you're in!

The final result will look like this:

![final flow](//images.ctfassets.net/2vbtnveccz5s/2Uw0VUVmbnPh669eM8Ur2b/309944a7cd0a1568d4c8b6935cfac246/final_flow.png)

## Create a new flow

Let's start by creating a new flow to cover this intent.

1.  Click on the 'Flow' icon in the top ribbon.
2.  Name the flow `User wants to know if loyalty program is free`.
3.  Click the arrow in the top left corner of the window to go to the main flow window.

![1-create flow](//videos.ctfassets.net/2vbtnveccz5s/1tkWqVpAy81wbsl19gC5bm/694ad96eb3b1b4347b0f9782ca4180ce/1-create_flow.mp4)

## Populate the trigger

The next step is to populate the trigger to cover the testing examples:

1.  Select the trigger and name it `Is the loyalty program free?`.
2.  Add a Intent trigger on the right and paste the following Intent examples into the field:

```example-inputs
Do I need to pay for the rewards program
How much does it cost to join the loyalty program
Is the rewards program free
What is the price of the loyalty program
```

![2-populate trigger](//videos.ctfassets.net/2vbtnveccz5s/Vs5PpleZManGTBZx465xU/4a3c719f176ab86f8ff9e1f0225c1ba1/2-populate_trigger.mp4)

## Generate a condition
At this point we can either force Teneo to generate a Match or manually select one we are interested in. Let us start off by manually adding a [TLML Syntax Requirement](/studio/flows/concepts/triggers#condition) and automatically drafting a condition.

1.  Scroll down to the 'Match' section and click on the 'Add' button. This will toggle a drop-down list of different Match to select.
2.  Select 'TLML Syntax'(Teneo Linguistic Modeling Language) and then click on the 'Advanced Options' button under the condition field.
3.  Finally, click on the 'Draft' button. This will draft a condition based on the examples given to the trigger.  

!!! Selecting 'Draft' will replace any TLML Syntax condition written inside the Syntax condition panel from the first place.

4.  After a while, the following condition will appear:

![3-draft condition](//videos.ctfassets.net/2vbtnveccz5s/3fnJITssnjexDdzaCtDC1Y/39fd10cd5068fbf8e7d178fc37a46071/3-draft_condition.mp4)

Here, we can see that Teneo used the [Intent examples](/article/build/flows/how-to/use-conditional-match-requirements#populate-the-trigger) to find matching [language objects](/studio/language-understanding/concepts/language-objects) and combine them in a language condition. This is human-readable and, if we understand the syntax, it can be fine-tuned to suit our needs. For now, we will just use the condition as is; later, we will see [how to further optimize this language condition](/studio/language-understanding/how-to/optimize-language-conditions) in order to shorten and increase the coverage of a Syntax condition.

!!! If you are developing using a language without any [Language Resources](/studio/language-understanding/concepts/lexical-resources), Teneo will generate a condition using plain words instead of [Language Objects](/studio/language-understanding/concepts/language-objects).

## Add an answer

To finish the flow, we need to add an answer text to the output.

1.  Select the Output Node and name it `You can join the loyalty program for free!`.
2.  Paste `You can join the loyalty program for free! Just ask your local barista for a club card and you're in!` into the 'Answers' field on the right.
3.  Hit 'Save'.

![4-populate output](//videos.ctfassets.net/2vbtnveccz5s/6HaibZXg8G31zoBxdh0Lxg/5b1218d397eeafce6f4aead33c4bcd5a/4-populate_output.mp4)

That's it! We now have a flow that includes a trigger with a TLML Syntax Match.

## Test yourself

Go ahead and test yourself by adding one more example, `Can I join the loyalty program without paying?` and draft the condition again following the steps from this page.


Build - Use TLML Syntax Match

Use TLML Syntax Match

Just as in human conversations, the user will assume your bot remembers what they recently have been talking about.  
Here you'll learn how to make your bot remember information from one flow to another. Consider the following conversation:

> **User**: Which coffee would you recommend? (*Flow: User wants bot to suggest a coffee*)  
> **Bot**: Easy choice, a __flat white__ of course!
> 
> **User**: I'll go for __one of those__ then. (*Flow: User wants to order a coffee*)  
> **Bot**: Ok, a __flat white__ will be ready for pickup in 5 minutes.

This conversation combines two flows: ['User wants bot to suggest a coffee'](/studio/flows/how-to/add-a-script-to-your-flow) and ['User wants to order a coffee'](/getting-started/build-a-slot-filling-flow). In the first flow, the bot recommends a 'flat white'. This coffee type is remembered. When the second flow is triggered and the user asks for "one of those" the bot understands that a 'flat white' should be ordered. In other words, 'flat white' is mentioned in one flow, and then used in another!

We will take the following steps to make this possible:

*  Create a [global variable](/article/build/flows/concepts/variables) that can store the coffee type.
*  Make sure the flow 'User wants bot to suggest a coffee' populates that global variable.
*  Make sure the flow 'User wants to order a coffee' retrieves the global variable and triggers on inputs like "I'll go for one of those then".

Once we're done, the 'User wants to order a coffee' flow will look like this: 

![final flow](//images.ctfassets.net/2vbtnveccz5s/1l9iR507NXeXuo431onXS1/2f391b12617c8a97703f110c985aa7dd/final_flow.png)

## Add a global variable
First we'll create the global variable to hold the coffee type:

1.  Open the 'SOLUTION' tab in the solution's window.
2.  Select 'Globals', and then select 'Variables'.
3.  Click 'Add'. A panel for specifying the new variable appears.
4.  Name the variable `coffeeTypeInFocus` and set its initial value to the empty string: `""`. (Make sure to edit the "Value" field and not the "Description" field.)
5.  Hit 'Save'.
6.  Return to the main solution view.
7.  In the Tryout panel, a message to 'Reload now' appears. After clicking it, you will be able to use the global variable in your flow.

We now have global variable which we can use to store a coffee type and in which turn can be used by other flows.

![1-add global variable](//videos.ctfassets.net/2vbtnveccz5s/3AlmEIh7hfKqYhJOdgCRyH/6c94ccd6698ad597e8675d71d071bc41/1-add_global_variable.mp4)

## Update the 'User wants bot to suggest a coffee' flow

Now we'll make sure that the recommended coffee in the flow ['User wants bot to suggest a coffee'](/studio/flows/how-to/add-a-script-to-your-flow) is stored in the global variable, so that it can be retrieved from other flows too. The flow uses a flow variable __coffeeSuggestion__ that needs to be copied to the global variable __coffeeTypeInFocus__.

To do so, we'll add a script in the flows 'On Drop' script event. Scripts in 'On Drop' are executed when the flow has finished and is about to be dropped from the [Flow stack](/studio/conversations/concepts/flow-stack).

In the script we'll first set the global variable __coffeeTypeInFocus__ to the value of the flow variable __coffeeSuggestion__.  
However, we don't want the coffee type to be remembered forever. Just like humans don't keep things in focus forever, your bot shouldn't either. Once the variable is set, we'll use a special method to specify that the value should be forgotten after a couple of turns (input-output turns). In Teneo that is called setting the lifespan of a variable. You set the lifespan of a variable with a script like the following:

![explain script](//images.ctfassets.net/2vbtnveccz5s/4DzOObuXnfuAIkZQjUPMnd/cc83c92d2731e6e9cb64637b2514d1ff/explain_script.png)

Let's update the flow:

1. Open the previously created, ['User wants bot to suggest a coffee'](/studio/flows/how-to/add-a-script-to-your-flow) in edit mode. 
2. Click on the 'FLOW' tab.
3. Select 'Scripts', and then click 'On Drop'.
4. Paste these lines to the empty script field:
	```groovy
   // Save flow variable coffeeSuggestion in global variable
   coffeeTypeInFocus = coffeeSuggestion

   // Set the lifespan of the global variable
   _.setSessVarLifespan('coffeeTypeInFocus',2)
	```
5. Hit 'Save' and close the flow.

![2-update suggest flow](//videos.ctfassets.net/2vbtnveccz5s/7agdoLsQnZgP1NOS4yPMJc/a151011c3472deb5ec122903837f1fe9/2-update_suggest_flow.mp4)

## Update the 'User wants to order a coffee' flow

We've come quite far already. We've set up a global variable that makes it possible to share information between flows, and made sure it's populated whenever your bot suggests a coffee type. Now we'll move on to retrieve and use the variable from within the flow ['User wants to order a coffee'](/getting-started/build-a-slot-filling-flow).

But first, we need to make sure that the flow triggers on inputs like "I'll go for one of those then". This should only happen when there is a __coffeeTypeInFocus__. The new trigger will therefore include a *context restriction* stating that the global variable must carry a value for the trigger to be applied. Now let's create the trigger:

1. Open the flow ['User wants to order a coffee'](/getting-started/build-a-slot-filling-flow) in edit mode.
2. Click on the Plus icon next to the trigger and add a new Intent trigger. This will add an additional trigger to the flow.
3. Name the trigger: `Can I have one of those?`.
4. Add a few example intents:
    ```example-inputs
    I'd like a large one
    I'll go for that then
    May I have one of those please?
    ```
5. Add a Match for 'TLML Syntax' and paste the following:
	```lml
    (
        (%I.FW.LEX &^ %WANT.VB.LEX &^ (one/%IT.FW.LEX))
        /
        (%I_WILL.PHR &^ %GO_FOR.VB.MUL &^ %IT.FW.SYN) 
    )^{ orderedCoffeeType = coffeeTypeInFocus }
   ```
6. Now we'll add the context restriction. Click on 'Add' in the Match section. 
7. Select 'Global Variable' and select the global variable __coffeeTypeInFocus__ that we [created earlier](/studio/conversations/how-to/share-information-between-flows#add-a-global-variable). 
8. Hit 'Save'.

![3-update order flow](//videos.ctfassets.net/2vbtnveccz5s/bwbzbgWTbUUrgpbmeDQer/533ea9d94e33de68b653789b48b34273/3-update_order_flow.mp4)

The flow 'User wants to order a coffee' keeps track of which coffee type the user asks for in the flow variable __coffeeType__. We'll now make sure that the flow variable __coffeeType__ is populated with the value stored in __coffeeTypeInFocus__ when our new trigger kicks in.

You can do this in at least two different places. Either you [attach a script](/studio/language-understanding/concepts/attached-scripts) directly to the trigger's language condition, or you add a [trigger listener](/article/build/conversations/concepts/listeners).  
Here we'll go for the former and attach a script snippet to the language condition.

An [attached script](/studio/language-understanding/concepts/attached-scripts) is executed when the condition it's attached to has matched the input. The flow variable __orderedCoffeeType__ will therefore be set to the value of __coffeeTypeInFocus__ when the condition is evaluated to true and our new trigger kicks in. And of course, we will then skip the question "what coffee type do you want" as we already know the answer to it.

## Try it out!

That's it! Now go ahead and give it a try in Tryout!

> **User**: Which coffee would you recommend? (*Flow: User wants bot to suggest a coffee*)  
> **Bot**: Easy choice, a __flat white__ of course!
> 
> **User**: I'll go for __one of those__ then. (*Flow: User wants to order a coffee*)  
> **Bot**: Ok, a __flat white__ will be ready for pickup in 5 minutes.

Hands-on

Create a new flow

Populate the trigger

Generate a condition

Add an answer

Test yourself

Next page