
## What can I automate with Shortcuts?
With Shortcuts, you can create custom, multi-step routines that can be triggered by a specific action or input. Automating daily tasks becomes a breeze. You can create shortcuts that automate tasks such as checking the weather, setting reminders, and opening specific apps at certain times. For example, a shortcut can be set to automatically open your favourite meditation app at the same time every day. Or you can streamline your social media workflow by creating a shortcut for updating multiple social media platforms at the same time or one that automatically adds watermarks to photos before posting them to Instagram.

## How much does Shortcuts cost? 
Shortcuts comes free with Apple devices.

## How can I learn how to automate with Shortcuts?
You've come to the right place - check out the tutorials below. Alternatively check out the community generated Shortcuts at [Routine Hub](https://routinehub.co/) or the [subreddit](https://www.reddit.com/r/shortcuts/) devoted to Shortcuts.

The iOS and Mac Shortcuts apps are automation tools that allow you to create custom workflows and actions using a drag-and-drop interface.

Shortcuts


## Overview

The last tutorial taught us how to create [automated emails](https://tinyautomations.com/posts/2022-07-19-Release-Process-Automation) using macOS shortcuts. However, you may want to automate creating a draft email to make it easier for you to conduct your regular email marketing campaigns. Once created you will only need to enter your recipients in the automated draft email.

We use Obsidian and the JSON text strings created in the previous tutorial to create a draft email. JSON text strings use Shortcuts to make the draft email automation.

[How to automate creating a draft email with Shortcuts - YouTube](https://www.youtube.com/watch?v=18JTHqigEsA)

## Flow
[![](https://mermaid.ink/img/pako:eNpVUE1rwzAM_StCI9BCe9ipI4fBaJvb2KFjJ1-UWG3MEjvIzqGE_PfJ_dg6DOb56T1JfhM2wTKWWBST8y6Vk8HUcs8GS4M1RQUruHFfJI7qjqMWQYWDuJ7kvA1dkIv-afNcVdX-aoncBG__16u3l-1uY3Ce56IwPp-T0NDC5y7jJO50YllsyUPN8FFHZ53iIBB0A4GbYGl8bIOkZkxxcbgjZXty3eJdr-VDO1iv70agMYWekgseyFsYKEZwHiwlUtkr_LZ9mJD9Y-SrKAVohCnpU-iYgPPIizWD65cAcIU9izJWo50y8xerQk3l26Dxs-rGQfvy3roUBMsjdZFXmNc8nH2DZZKR76KdI02rv6nmH436mcY)](https://mermaid.live/edit#pako:eNpVUE1rwzAM_StCI9BCe9ipI4fBaJvb2KFjJ1-UWG3MEjvIzqGE_PfJ_dg6DOb56T1JfhM2wTKWWBST8y6Vk8HUcs8GS4M1RQUruHFfJI7qjqMWQYWDuJ7kvA1dkIv-afNcVdX-aoncBG__16u3l-1uY3Ce56IwPp-T0NDC5y7jJO50YllsyUPN8FFHZ53iIBB0A4GbYGl8bIOkZkxxcbgjZXty3eJdr-VDO1iv70agMYWekgseyFsYKEZwHiwlUtkr_LZ9mJD9Y-SrKAVohCnpU-iYgPPIizWD65cAcIU9izJWo50y8xerQk3l26Dxs-rGQfvy3roUBMsjdZFXmNc8nH2DZZKR76KdI02rv6nmH436mcY)
```mermaidignore
graph TD

trigger(Can be Obsidian or other trigger)
shortcuts(Shortcuts)
mail(Mail)

trigger -- trigger automation and pass in data --> shortcuts
shortcuts -- use data to create draft email --> mail

```

## Let's recreate this automation

### Resources
- [TA Create draft email (icloud.com)](https://www.icloud.com/shortcuts/2b188b2d60574a8ca87f47d881b2e4a4)
- [Obsidian](https://obsidian.md/)

### Step 1: Create empty shortcut and check JSON

- The first step is to add a blank shortcut.
-  In this case, we will add the show results node to the shortcut to test the JSON. Drag the **Show Result** node from the right side panel and drop it below the empty shortcut.

![Drop the Show Result node at the end of the workflow](https://ry.d.pr/1gcMZr.png)

-  Click the **Release email** button created in the [previous tutorial](https://tinyautomations.com/posts/2022-07-19-Release-Process-Automation) in your dataview to check if the JSON runs. 

**Note:** After every step of this draft email automation tutorial, check if it works correctly using the Show Results node. If it works, delete the Show Result node and continue to step 2.

### Step 2: Create dictionary from JSON

-  Go to the "Input search" label in the right panel and type **Get Dictionary from Input.** The results will bring up the dictionary. Click **Get dictionary from** Input, which will be inserted below your shortcut.

![](https://ry.d.pr/wIrkQe.png)

The dictionary helps JSON to insert the email title, description, and tags into the draft email. Now let's add information to the dictionary.

- Search **text** in the "input search" label. Check the results for the **Text** node, drag and drop it under the dictionary.
- Click **Text** and type the body of your email. 
![](https://ry.d.pr/gJjiqF.png)


If you have a description of your email body saved in your dictionary, you can insert the description at the end of the sentence.

- Right-click where you want the description to appear in the **Text** node. Select **Insert Variable** and click **Dictionary** in the drop-down list.

![Click dictionary in the dropdown list screenshot](https://ry.d.pr/qUhcpR.png)

- The Dictionary properties will appear. Here you can set the information you want to be displayed - type **Description** in the **Get Value for Key** input. 

![Get value for key input screenshot](https://ry.d.pr/qUhcpR.png)

Check the JSON to ensure the automation is working correctly. As explained in `Step 1` insert a **Results** node under the workflow created. The result should appear like in the image below: 

![Create draft email screenshot](https://ry.d.pr/FSTgfq.png)

### Step 3: Create the body of the email

- Next, we set a variable to indicate the body of the email. Go to the "Input search" label on the right-side panel and type **Set Variable**. Click the result **Set Variable** to insert it into the workflow.

![Set variable screenshot](https://ry.d.pr/KGhf8k.png)


- Giving the variable a name will help you to find it easily when automating all the variables in the last step of this tutorial. Click the variable name and type "Body".
- Insert a **text** node to type in the details of the email body. Check `Step 2` to insert the text node. Right-click in the Text node and select **Insert Variable** , then click **Dictionary**.

![Insert dictionary screenshot](https://ry.d.pr/vM77tv.png)

- The **Text** properties will appear. Go to **Get Value for Key** and type "Title". Press **return** when done. 

![Get Value for Key "title" screenshot](https://ry.d.pr/mvSLkZ.png)

**Note:** Use the **Show Results** node to check JSON, as seen in `Step 1`. If it brings up the body description, continue to the next step.

### Step 4: Create the subject variable

We have to set the body into a variable. Go to the **Input search** label and search for **Variable.** Select **Set Variable** from the results. Name the variable as "Subject".

![Create the subject variable screenshot](https://ry.d.pr/bXWQNr.png)

### Step 5: Automate email creation

- For the final step, search **Mail** in the **Input search** label. Click **Send Mail** from the results.

![Select Send Mail screenshot](https://ry.d.pr/GR3DW9.png)

- The send mail node will appear under the workflow. Let's set the first and last input box in the node as **Body** and **Title** respectively. Right-click the first textbox and select **Insert Variable** and then click **Body**.

![Insert "Body" Variable screenshot](https://ry.d.pr/7gnOIH.png)

-  For the last input box in the **Send email** node, right-click the input and select **Insert Variable** and then click **Subject**.

**Note:** Since it is a draft email, the **Recipients** input in the middle of the **Send email** node should remain empty.

-  Finally, the draft email automation is completed. To preview the results, go to the Obsidian dashboard and click the **Release email** button created in the [previous tutorial.](https://tinyautomations.com/posts/2022-07-19-Release-Process-Automation) The final automated draft email should appear as below.

![Release email screenshot](https://ry.d.pr/jOn9bc.png)



Bored of sending the same old emails? Let Shortcuts do the heavy lifting.

How to automate draft email creation with Shortcuts

## How do I automate emails from Obsidian on a Mac?
To automate emails from Obsidian you can use macOS Shortcuts.
* Make sure you fill in the relevant data as YAML front matter in Obsidian.
* Create a button within Obsidian to trigger the macOS Shortcut.
* Create a macOS Shortcut to take the data from Obsidian and create an email in Mail.

[How I reduced release email stress with this automation - YouTube](https://www.youtube.com/watch?v=sFIXR0TuxX8)

This tutorial will cover the triggering of the macOS Shortcut within Obsidian and the following tutorial will cover the creation of the email with Shortcuts.

## Flow
```mermaidignore
graph TD

obsidian(Obsidian)
shortcuts(macOS Shortcuts)
mail(Mail)

obsidian -- pass frontmatter data --> shortcuts
shortcuts -- create email with frontmatter data --> mail
```

![](https://mermaid.ink/svg/pako:eNptUE1rwzAM_StCI5BCetipI4fBaJvb6KFjJ1_URF1MYzvYCqOE_Pcpa7t1MAzm6X1ha8Q6NIwlZtlovZVyNCgtOzZYGjxQUlDAlXunaOnQcVIR1NhH6yie16EL8dv_sHqsqmp7iSSug2_-6tXL03qzMjhNU5YZP5-PSH0Lb5sZh0OyjSWf765gYXxqQ5R6kJQ7qnd72N9m1RzZLn_Va3GfhuUSekoJjjF4cSTCERoSUuEZfvruqudEHZmEgedO-LTS_h-f5cvDAbBAx1GZRhc4zszv8hTq308GjZ_UN_TawNvGSohYHqlLXCANEvZnX2MpceCbaWNJd-KurukLkX6RGw)


## How do I automate an email with Obsidian on a Mac?
### Step 1: Create a page in Obsidian with all the email details
This information should also include anything you want to filter in your [Obsidian dataviews](https://github.com/blacksmithgu/obsidian-dataview) and anything you want to include in your emails. The simplest way to do this is within the [YAML front matter](https://help.obsidian.md/Advanced+topics/YAML+front+matter) of the Obsidian markdown document.

#### What is an Obsidian dataview?
An [Obsidian dataview](https://github.com/blacksmithgu/obsidian-dataview) allows you to create tables by querying your Obsidian vault. It works like querying a traditional database but with a dataview you query your markdown files within your vault. We will use Obsidian buttons within each row of this dataview to trigger the macOS shortcut that creates the email.

#### What is YAML front matter in Obsidian?
YAML front matter is text at the top of your Obsidian markdown document surrounded with three dashes `---`. You can store data associated with the file such as `tags`, `title`, `description` and `published`. The below image shows the type of data we have used for this automation.

![YAML front matter example](https://ry.d.pr/bCE8wU.png)


### Step 2: Create an Obsidian dataview that lists your unpublished blog posts
In a page embed the following code:
````
```dataview
TABLE "BUTTON" AS " "
FROM "tiny-automations" SORT date DESC
WHERE published = false AND contains(sites, "tinyautomations.com")
```
````

This will create a table that contains all the files within the `tiny-automations` folder where `released` is `false` and `sites` contains `tinyautomations.com`. This will list all blog posts that haven't been published yet.

You'll notice we have the text `BUTTON` that appears in the second column. We are going to replace that text with code for a clickable button to trigger the automation.

### Step 3: Create a button within your dataview
In place of the `BUTTON` text we want a `Release email` button that we can click to trigger the automation. We do this by swapping out the `BUTTON` text in the dataview with the code for a button. Here is an example of how to embed a button in Obsidian:

````
```button
name Release email
type link
action shortcuts://run-shortcut?name=Create%20draft%20email&input=text&text=INPUT_DATA_HERE
class button-css
```
````

This will create a standalone button that runs a macOS Shortcut named `Create draft email` (the `%20` is a URL encoded version of a space character). We want to embed this button in each dataview row so that when we click it it runs the `Create draft email` shortcut with data from our markdown documents.

To embed the button in the dataview we need to replace the `BUTTON` text with the above `button` code:
````
```dataview
TABLE "```button
name Release email
type link
action shortcuts://run-shortcut?name=Create%20draft%20email&input=text&text=INPUT_DATA_HERE
class button-css
```" AS " "
FROM "tiny-automations" SORT date DESC
WHERE published = false AND contains(sites, "tinyautomations.com")
```
````



This will create a dataview with a `Release email` button that looks like this:

![Obsidian dataview screenshot](https://ry.d.pr/nfhRX2.png)


### Step 4: Pass data into the shortcut
This is the most complicated step. We want to pass data into the macOS shortcut from Obsidian. To do this we replace the `INPUT_DATA_HERE` text with a JSON object filled with data from your markdown files. JSON is a way of constructing data that follows a format like:
```json
{
	"property1": "value1",
	"property2": "value2"
}
```

We want to pass in the `title`, `description` and `tags` of the relevant page to the shortcut (we can then create an email from this data). So the JSON we want to create will look like this:
```json
{
	"title": "Title of page goes here",
	"description": "Description of page goes here"
	"tags": "Tags from page go here"
}
```

As you can see we need to fill in the values with the correct text from the YAML front matter of each page in each of the rows of the dataview. Obsidian dataviews allow us to access the files front matter with the variable `file.frontmatter` - so if I wanted to reference the `title` from the front matter I could use `file.frontmatter.title`. Replacing the text above with correct data from each row we get:
```json
{
	"title": file.frontmatter.title,
	"description": file.frontmatter.description
	"tags": file.frontmatter.tags
}
```

There are two more steps to make this actionable. We need to replace certain strings (text) with their URL encoded counterparts - this is to make it machine readable. We also have to do some `escaping` of characters for this reason as well - especially with  `\"` as it is an embedded string. This may look a little complex but after a while you get used to it.

If we construct the JSON so it is readable within the Obsidian dataview it will look like this:
```json
replace(replace(replace(replace(replace(replace(
	"{\"title\": \"" + file.frontmatter.title +
	"\", \"description\":\"" + file.frontmatter.description + 
	"\", \"tags\":\"" + file.frontmatter.tags + "\"}", " ", "%20"), "/", "%2F"), "?", "%3F"), "=", "%3D"), ":", "%3A"), "&", "%26")
```

We then need to add this to the button code:
````
```button
name Release email
type link
action shortcuts://run-shortcut?name=TA%20Create%20draft%20email&input=text&text=" + replace(replace(replace(replace(replace(replace(
	"{\"title\": \"" + file.frontmatter.title +
	"\", \"description\":\"" + file.frontmatter.description + 
	"\", \"tags\":\"" + file.frontmatter.tags + "\"}", " ", "%20"), "/", "%2F"), "?", "%3F"), "=", "%3D"), ":", "%3A"), "&", "%26") + "
class button-css
```
````
This is is the button complete. We replaced `INPUT_DATA_HERE` with the JSON we created above. Now if we replace the `BUTTON` text in the dataview with the above button we get the completed code of: 
````
```dataview
TABLE "```button
name Release email
type link
action shortcuts://run-shortcut?name=Create%20draft%20email&input=text&text=" + replace(replace(replace(replace(replace(replace(
	"{\"title\": \"" + file.frontmatter.title +
	"\", \"description\":\"" + file.frontmatter.description + 
	"\", \"tags\":\"" + file.frontmatter.tags + "\"}", " ", "%20"), "/", "%2F"), "?", "%3F"), "=", "%3D"), ":", "%3A"), "&", "%26") + "
class button-css
```" AS " "
FROM "tiny-automations" SORT date DESC
WHERE published = false AND contains(sites, "tinyautomations.com")
```
````

This dataview now lists all the not yet published blog posts. When we click the `Release email` button it will trigger the macOS Shortcut `Create draft email` (covered in our next tutorial) and we can create our release email.

## Resources
- [Obsidian](https://obsidian.md/) 
- [blacksmithgu/obsidian-dataview: A high-performance data index and query language over Markdown files, for https://obsidian.md/. (github.com)](https://github.com/blacksmithgu/obsidian-dataview)
- [shabegom/buttons: Buttons in Obsidian (github.com)](https://github.com/shabegom/buttons)
- [YAML front matter - Obsidian Help](https://help.obsidian.md/Advanced+topics/YAML+front+matter)
- [JSON Introduction (w3schools.com)](https://www.w3schools.com/js/js_json_intro.asp)




Release emails are necessary to communicate to the wider business but can be tedious. Use automation to make them a joy to send.

How I took the stress out of release emails using Obsidian dataviews and macOS shortcuts

## Overview of the n8n and Shortcuts bin day automation
Be the envy of your street by using n8n and Shortcuts to let you know what colour bins are meant to go out.

This tutorial will show you how to use n8n as a backend and Shortcuts (macOS or iOS) as a front end client.

[Bin day automation - how to remember what colour bins need to go out - YouTube](https://www.youtube.com/watch?v=PY35t81IUL0)

## Take out the correct bins automation flow
![Bin day automation flow diagram](https://mermaid.ink/svg/pako:eNpVkE1rwzAMhv-K0Ai0kB52aslhUJIGdhtsbDB8UWx3MUvs4I9DCPnvU7I1owjBK-mRhDShdEpjgVk2GWtiMQmMre61wEJgQ4FFDn-5d_KGmk4HLgKDgzc9-bF0nfMr_3B8rOv68tsStHRW3dfr86msjgLnec4yYRf78jS08FYtOrTOR5li2G1qL6w92R37_o6AwwFK6jpojAVFI5xfnjn3BEyuLQvw0VIEyeuTX7noYEgRHPuCbsMwx177noziT0zCAvx_gSUf8S1Q2Jm5NCiK-qJMdB6LK3VB50gputfRSiyiT_oGVYb4uH6jBrKfzt3i-QdCgIBn)
```mermaidignore
graph TD

shortcuts(shortcuts)
n8n(n8n)

shortcuts -- Call bin day API --> n8n
n8n -- What colour bin to put out --> shortcuts
```

## How to recreate this automation
### Resources
- [Bin Day Shortcut for macOS/iOS](https://www.icloud.com/shortcuts/9beb8e54e8c8470b929c4b62f0193184)
- [n8n workflow](https://github.com/rymawby/tiny-automations-source/blob/main/bin-day-n8n-and-shortcuts/bin_day_api.json)
- [n8n.io - Free and Open Workflow Automation Tool](https://n8n.io/)


### Step 1: Use n8n to create an API
This automation is simple enough that you don't really need this API - as currently the only data I could get was a PDF detailing what bins need to go out. If this changes in the future and I move somewhere with a better bin day website or even it's own API I will just have to change this backend and not the frontend Shortcut.

The n8n backend consists of 3 nodes. A `Webhook` node that we can call via a URL, a `Function` node that figures out what colour bins need to go out next Tuesday (my bin day) and then a `Respond to Webhook` node that returns the data from the `Function` node.

![Bin day API call in n8n](https://ry.d.pr/TW1MvE.png)

If you open the `Bin day` node you can see the URL you need to retrieve the data from this workflow. Take note of this URL as you will need to use it in your Shortcut. We are using `GET` as the `HTTP Method` as we do not need to pass in any parameters. (it would be worth adding some kind of `Authentication` too).

Not also we have set `Respond` to `Using 'Respond to Webhook' node` - this is how we will return the data from the `Function` node.

![The Bin Day URL](https://ry.d.pr/tfxLxt.png)

In the `Function` node we calculate what bins are out the following Tuesday - or today if today is Tuesday. My bins just alternate colours every week - yours may be different and you'd have to analyse and modify the code so it's relevant to you. But my code is something like this: 

```javascript

function getNextDayOfTheWeek(dayName, excludeToday = true, refDate = new Date()) {
    const dayOfWeek = ["sun","mon","tue","wed","thu","fri","sat"]
                      .indexOf(dayName.slice(0,3).toLowerCase());
    if (dayOfWeek < 0) return;
    refDate.setHours(0,0,0,0);
    refDate.setDate(refDate.getDate() + +!!excludeToday + 
                    (dayOfWeek + 7 - refDate.getDay() - +!!excludeToday) % 7);
    return refDate;
}

function daysBetweenTwoDates(startDate, endDate) {
  var millisecondsPerDay = 24 * 60 * 60 * 1000;
  return Math.round((endDate - startDate) / millisecondsPerDay);
}

function isItFortnightlySince(days) {
  return days % 14 === 0;
}

const INITIAL_BIN_DAY = new Date(2022, 0, 4);
const nextBinDay = getNextDayOfTheWeek("Tuesday", false);

const daysBetweenBinDays = daysBetweenTwoDates(INITIAL_BIN_DAY, nextBinDay);

var binColor = "";
if(isItFortnightlySince(daysBetweenBinDays)){
  binColor = "Blue and Green";
} else{
  binColor = "Yellow";
}

items[0].json = {announce: "Put out the " + binColor + " bins."};

return items;
```

Notice the format we return data in n8n - the `items[0].json` usage is so that we can pass data between nodes - also note that the property we are setting is named `announce`.

In the `Respond to Webhook` node just return the `First incoming item`. 
![Respond to Webhook setup](https://ry.d.pr/8CtSX3.png)

Test it out, save and activate - your n8n API is up and running.

### Step 2: Create a Shortcut that calls your n8n API
Now you've set up your n8n backend you can create a Shortcut that calls this API and then displays what it returns. Below is in macOS but you can do the same on iOS/iPadOS.

Re-create the Shortcut as below but with your URL from `Step 1`. We call that URL, that the contents of the URL and then grab the value for `announce` and display it with a `Show Result` node.

![The Shortcut](https://ry.d.pr/kogO8t.png)

Now run your Shortcut - it should call your n8n backend and then display the result.

Be the envy of your street by putting the right colour bins out every week.

Bin day automation using n8n and Shortcuts

## Overview
This automation uses Airtable to store a knowledge base and n8n as both the trigger and the source/backend. The questions and answers are displaying in Shortcuts. This isn't the quickest or, to be honest, most logical automation as it stands - but it could be the start of a whole knowledge system - with different sources and different triggers - hence the use of n8n to trigger as well as grabbing the dataset from Airtable.

[Knowledge System using automation and n8n, Pushcut, Airtable & Shortcuts. - YouTube](https://www.youtube.com/watch?v=o6xDXIdD7KI)

## How to improve your recall using n8n, Pushcut, Shortcuts and Airtable automation flow diagram

![How to improve your recall using n8n, Pushcut, Shortcuts and Airtable automation flow diagram](https://mermaid.ink/svg/pako:eNp9UcFqg0AQ_ZVli2AgofSU4KFQYvyBlh7KXia61aU6a2Z3Kan47x2NmrSHsMi-mXlvnsvrZG4LLRMZRZ1B45NOSV_pRiuZKHkEx2Atpt47kIFjrR0PBRNbMg3QeW9rSyP_YfuUZdnhInE6t1j8nWcvu326VbLv-yhSOJySoK3EWzpg3GHM30phG1yVBx9PN3dcZckzdPGCuAuG_PBL8QxW0x6x2YicLApPpiw1cf0spm3L-oE0z0_B_IykZf2N50AkfQraeUGAhW3EWBiLj4Due9rPvos5aR8I77FvjBbNxeI_uwDPSfhRNT_0-vZBWer7KjaQa9loasAUHHenUIhr1Aw5qS8lFfbMCy1r9aEw3pJMPqF2ei0hePt6xlwmnoKeSakBTrBZWC3gh7Vz3f8Cg0nVdQ)
```mermaidignore
graph TD

n8n(n8n)
pushcut(pushcut)
shortcuts(shortcuts)
airtable(airtable)

n8n -- cron trigger --> pushcut
pushcut -- trigger quiz --> shortcuts
shortcuts -- request random question/answer --> n8n
n8n -- return random question/answer --> shortcuts
n8n -- request question/answer dataset --> airtable
airtable -- get question/answer dataset --> n8n
```

## How to recreate this automation
### Resources
* [Github source](https://github.com/rymawby/tiny-automations-source/tree/main/improving-your-recall-with-automation)
* [n8n workflow](https://github.com/rymawby/tiny-automations-source/blob/main/improving-your-recall-with-automation/Knowledge_System.json)
* [Trivia Airtable](https://airtable.com/shrACk3hEub3dTD47)
* [Quiz shortcut](https://github.com/rymawby/tiny-automations-source/blob/main/improving-your-recall-with-automation/Quiz.shortcut)

### Step 1: The trigger
I wanted to view the questions on my phone once an hour every hour 9am-5pm. To do this is a 2 step process. I have n8n setup with a cron job to trigger on the hour during these hours and this calls Pushcut on my phone (via webhook).
![n8n trigger workflow](https://ry.d.pr/GAZ4Gd.png)

### Step 2: Run the Quiz shortcut on your phone
Pushcut opens the Quiz shortcut workflow. The Quiz shortcut then calls a webhook on n8n which get's a random question from the trivia Airtable dataset. The shortcut then displays the question before displaying the answer. The Quiz shortcut looks like this:
![Quiz shortcut](https://ry.d.pr/zBHtL6.png)

And the n8n workflow it calls via webhook:
![n8n get question workflow](https://ry.d.pr/B5HRo6.png)

### Step 3: The Airtable dataset
I just quickly imported some random questions I found on the [Open Trivia DB](https://opentdb.com/api.php?amount=10) for demo purposes. With Airtable you can actually import the JSON outputted.
![](https://ry.d.pr/QFcqVd.png)

## Future enhancements
* Different triggers - Shortcut automations, manually, location based etc.
* More sources - n8n could pull in more than just from Airtable, maybe from your Anki database, Readwise excerpts etc.
* Caching - n8n could cache the questions nightly so it runs quicker.


Create a knowledge system with n8n, airtable, pushcut and shortcuts.

Improving your recall with automation

This tiny automation allows you to allocate your income automatically. It runs a service on n8n so that anyone with the shortcut can run the same numbers.

## Income allocator automation flow diagram
![Income allocator automation flow diagram](https://mermaid.ink/svg/pako:eNpVkDFrw0AMhf_KoWJIIBnSDAkeCm0Sjx2a0qHcovjU5IgtmbNuCMb_vWenbilanvQ-PZA6KMUR5JBlnWeveWdBL1SThdzCCdskFuZn9oHB46miNpkmgU3wNYbbTioJI_-wWRVFcbivtFQKu_9-8bzd7TcW-r7PMstDnQM2F_O-H7R3q9kL8nU-yMfZ8SJBy6jt2K9nvOX5D2aWS_MqSgZriaymQe_S7MmkvXF5AA6sFCbibq7HpMF8I42BzSm6M6nBqpIS1QtPKbCAmkKdctN3OsvG_H0myXTY1YLlPnGxcah0cF4lQP6FVUsLwKhyvHEJuYZIE7T3mA6uf6kG-VNk6vtvTQWEYg)

```mermaidignore
graph TD

id1(Bank)
id2(Shortcuts)
id3(n8n)

id1 -- Note amount paid --> id2
id2 -- Enter amount --> id3
id3 -- Return budget allocation --> id2
```

## Step 1. Get paid
The best step. Note how much - this income allocator can take in any amount and still split it to the same percentages.

## Step 2. Create a shortcut that takes in your income amount
Create a shortcut that posts to the webhook you are going to create in **Step 3**. It should be a `POST` request with `amount` added to the request body. The blurred out bit is the `URL` of the n8n webhook.
![](https://ry.d.pr/tDoWQ8.png)

## Step 3. Create an n8n workflow
Create a webhook workflow that contains 2 nodes - a webhook and a function node.
![The n8n income allocator workflow](https://ry.d.pr/bl9jve.png).

The webhook listens and receives the data that is sent from the shortcut in **Step 2**. We then do a calculation in the function and return that data as a response. Something like this:
```js
total = Number(items[0].json.body.amount);
treatMoney = Math.floor(total * 0.05);
savingsMoney = Math.floor(total * 0.35);
expensesMoney = Math.floor(total * 0.55);
items[0].json.display = "Money into everyday expenses: $" + expensesMoney.toString() + "\nMoney into savings: $" + savingsMoney.toString() + "\nMoney into each spending account: $" + treatMoney;
return items;
```

It just responds with a simple, human readable string with instructions where to allocate the money. This string is then displayed by the shortcut.

You could make this more complex if you have different budgetting needs. I really love this simple architecture - you could use it to do all manner of things.

 If you liked enjoyed this tiny automation please do share the [original twitter thread](https://twitter.com/TinyAutomations/status/1485575632788471809?s=20).

Learn how to automate with Shortcuts

What can I automate with Shortcuts?

How much does Shortcuts cost?

How can I learn how to automate with Shortcuts?