Repository: bacalhau-project/bacalhau (language: python)

Issue:
Node evicition policy cannot be configured in requester node store
The TTL is hard-coded to 10 Mins https://github.com/bacalhau-project/bacalhau/blob/main/pkg/node/node.go#L184
This may be a sane default for some use cases, but probably not all. We should allow this value to be configured by operators.
122. Update scale testing framework
With new tests for the cases in this phase.


Discussion / hints:

Fix patch:
diff --git a/.cspell-docs.json b/.cspell-docs.json
index 203b0484e4..50b2c7110d 100644
--- a/.cspell-docs.json
+++ b/.cspell-docs.json
@@ -21,10 +21,21 @@
         "./docs/swagger.json",
         "./docs/docusaurus.config.js",
         "./docs/sidebars.js",
-        "**/*.css"
+        "./docs/docs/dev/cli-reference/all-flags.md",
+        "./docs/docs/dev/api/jobs.md",
+        "**/*.css",
+        "**/cli-reference/**",
+        "**/api/**",
+        "./docs/docs/dev/databases.md",
+        "./docs/docs/dev/setting_up_development.md"
     ],
     "ignoreRegExpList": [
         "Urls",
+        "saturnia",
+        "Niels",
+        "TKNG",
+        "runc",
+        "Kernighan",
         "Email",
         "RsaCert",
         "SshRsa",
diff --git a/docs/docs/community/_category_.yml b/docs/docs/community/_category_.yml
index 75a4b73872..1db1fbb294 100644
--- a/docs/docs/community/_category_.yml
+++ b/docs/docs/community/_category_.yml
@@ -1,2 +1,3 @@
 label: "Community"
-position: 100
+link:
+  type: 'generated-index'
diff --git a/docs/docs/data-ingestion/_category_.yml b/docs/docs/data-ingestion/_category_.yml
deleted file mode 100644
index 1b0bd32f27..0000000000
--- a/docs/docs/data-ingestion/_category_.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-label: "Data Ingestion"
-position: 4
\ No newline at end of file
diff --git a/docs/docs/data-ingestion/index.md b/docs/docs/data-ingestion/index.md
deleted file mode 100644
index a6e56cd2ea..0000000000
--- a/docs/docs/data-ingestion/index.md
+++ /dev/null
@@ -1,4 +0,0 @@
----
-sidebar_label: Data Ingestion"
-sidebar_position: 4
----
\ No newline at end of file
diff --git a/docs/docs/data-ingestion/pin.md b/docs/docs/data-ingestion/pin.md
deleted file mode 100644
index 3db2b8b511..0000000000
--- a/docs/docs/data-ingestion/pin.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-sidebar_label: "Pinning data"
-sidebar_position: 2
-description: "How to pin data to public storage"
----
-# Pinning Data
-
-If you have data that you want to make available to your Bacalhau jobs (or other people), you can pin it using a pinning service like Web3.Storage, Pinata, etc. Pinning services store data on behalf of users. The pinning provider is essentially guaranteeing that your data will be available if someone knows the CID. Most pinning services offer you a free tier, so you can try them out without spending any money.
-
-## Web3.Storage
-
-This example will demonstrate how to pin data using Web3.Storage. Web3.Storage is a pinning service that is built on top of IPFS and Filecoin. It is free to use for small amounts of data and has a generous free tier. You can find more information about Web3.Storage [here](https://web3.storage/).
-
-- First you need to create an [account](https://web3.storage/login/) (if you don't have one already).
-- Next, sign in and browse to the [Create API Key](https://web3.storage/tokens/?create=true) page. Follow the instructions to create an API key. Once created, you will need to copy the API key to your clipboard.
-
-### Ways to pin using web3.storage
-
-1. **Pin a local file using their test client**: To test that your API key is working, use [web3.storage's test client](https://bafybeic5r5yxjh5xpmeczfp34ysrjcoa66pllnjgffahopzrl5yhex7d7i.ipfs.dweb.link/).
-
-You can now see (or upload) your file via the web3.storage [account page](https://web3.storage/account/).
-
-:::warning
-Note that you shouldn't share your API key with anyone. Delete this API key once you have finished with this example.
-:::
-
-2. **Pin a local file via curl**: You can also pin a file via curl. Please view the [API documentation](https://web3.storage/docs/reference/http-api/) to see all available commands. This example submits a single file to be pinned.
-
-```bash
-export TOKEN=YOUR_API_KEY
-echo hello world > foo.txt
-curl -X POST https://api.web3.storage/upload -H "Authorization: Bearer ${TOKEN}" -H "X-NAME: foo.txt" -d @foo.txt
-```
-
-3. **Pin multiple local files via Node.JS**: Web3.Storage has a [node.js library](https://web3.storage/docs/reference/js-client-library/) to interact with their API. The following example requires node.js to be installed. The following code uses a docker container. The javascript code is located on [their website](https://web3.storage/docs/intro/#create-the-upload-script) or on [github](https://github.com/bacalhau-project/examples/blob/main/data-ingestion/nodejs/put-files.js).
-
-First, create some files to upload.
-
-```python
-%%writefile nodejs/test1.txt
-First test file
-```
-
-Then run the following command, which uses the environmental variable `TOKEN` to authenticate with the API.
-
-```bash
-export TOKEN=YOUR_API_KEY
-docker run --rm --env TOKEN=$TOKEN -v $PWD/nodejs:/nodejs node:18-alpine ash -c 'cd /nodejs && npm install && node put-files.js --token=$TOKEN test1.txt test2.txt'
-```
-
-The response will return the CID of the file, which can now be used as an input to Bacalhau.
-
-4. **Pin a file from a URL via Curl**: You can use curl to download a file and then re-upload it to web3.storage. For example:
-
-```bash
-export TOKEN=YOUR_API_KEY
-curl -o train-images-idx3-ubyte.gz http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
-curl -X POST https://api.web3.storage/upload -H "Authorization: Bearer ${TOKEN}" -H "X-NAME: train-images-idx3-ubyte.gz" -d @train-images-idx3-ubyte.gz
-```
-
-
-5. **Pin a file from a URL via Node.JS**: You can combine the node.js example above with a `wget` to then upload it to web3.storage.
-
-```bash
-docker run --rm --env TOKEN=$TOKEN -v $PWD/nodejs:/nodejs node:18-alpine ash -c 'cd /nodejs && wget http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz && npm install && node put-files.js --token=$TOKEN train-images-idx3-ubyte.gz'
-```
-
diff --git a/docs/docs/dev/_category_.yml b/docs/docs/dev/_category_.yml
index 5b20643061..ab4081e090 100644
--- a/docs/docs/dev/_category_.yml
+++ b/docs/docs/dev/_category_.yml
@@ -1,2 +1,2 @@
-label: "Developing Bacalhau"
+label: "Advanced Guides"
 position: 110
diff --git a/docs/docs/dev/api/_category_.yml b/docs/docs/dev/api/_category_.yml
new file mode 100644
index 0000000000..50024f7292
--- /dev/null
+++ b/docs/docs/dev/api/_category_.yml
@@ -0,0 +1,2 @@
+label: "API Guide"
+position: 2
\ No newline at end of file
diff --git a/docs/docs/references/api/agent.md b/docs/docs/dev/api/agent.md
similarity index 100%
rename from docs/docs/references/api/agent.md
rename to docs/docs/dev/api/agent.md
diff --git a/docs/docs/references/api/index.md b/docs/docs/dev/api/index.md
similarity index 100%
rename from docs/docs/references/api/index.md
rename to docs/docs/dev/api/index.md
diff --git a/docs/docs/references/api/jobs.md b/docs/docs/dev/api/jobs.md
similarity index 96%
rename from docs/docs/references/api/jobs.md
rename to docs/docs/dev/api/jobs.md
index fc8670ca30..9ea9c45fea 100644
--- a/docs/docs/references/api/jobs.md
+++ b/docs/docs/dev/api/jobs.md
@@ -16,7 +16,7 @@ Retrieve the specification and current status of a particular job.
   - `:jobID`: Identifier of the job to describe. This can be full ID of the job (e.g. `j-28c08f7f-6fb0-48ed-912d-a2cb6c3a4f3a`) or just the short format (e.g. `j-28c08f7f`) if it's unique.
 
 **Response**:
-- **Job** <code>(<a href="../job-specification/job">Job</a>)</code>: Specification for the requested job.
+- **Job**: Specification for the requested [job](../../setting-up/jobs/job-specification/job.md).
 
 **Example**:
 ```bash
@@ -103,7 +103,7 @@ Retrieve a list of jobs.
   - `reverse`: Opt to reverse the default order of displayed jobs.
 
 **Response**:
-- **Jobs <code>(<a href="../job-specification/job">Job</a>[])</code>**: List of matching jobs.
+- **[Jobs](../../setting-up/jobs/job-specification/job.md)**: List of matching jobs.
 - **NextToken** `(string)`: Pagination token.
 
 **Example**:
@@ -142,7 +142,7 @@ curl --get 127.0.0.1:1234/api/v1/orchestrator/jobs --data-urlencode 'labels=env
 Submit a new job for execution.
 
 **Request Body**:
-  - **Job** <code>(<a href="../job-specification/job">Job</a>)</code>: JSON definition of the job.
+  - **[Job](../../setting-up/jobs/job-specification/job.md)**: JSON definition of the job.
 
 **Response**:
 - **JobID** `(string)`: Identifier for the new job.
@@ -474,12 +474,12 @@ curl 127.0.0.1:1234/api/v1/orchestrator/jobs/j-412c34b4-da77-4a46-886c-76e03615a
 Fetch results published by all executions for the defined job. Applicable only for `batch` and `ops` jobs.
 
 **Response**:
-- **Results** <code>(<a href="../job-specification/spec-config">SpecConfig</a>)</code>: List of all published results.
+- **[Results](../../setting-up/jobs/job-specification/spec-config.md)**: List of all published results.
 - **NextToken** `(string)`: Pagination token.
 
 **Example**:
 
-Result of a job that used the [S3 Publisher](../other-specifications/publishers/s3):
+Result of a job that used the [S3 Publisher](../../setting-up/other-specifications/publishers/s3):
 ```bash
 curl 127.0.0.1:1234/api/v1/orchestrator/jobs/j-479d160f-f9ab-4e32-aec9-a45554126450/results
 {
diff --git a/docs/docs/references/api/nodes.md b/docs/docs/dev/api/nodes.md
similarity index 100%
rename from docs/docs/references/api/nodes.md
rename to docs/docs/dev/api/nodes.md
diff --git a/docs/docs/dev/cli-reference/_category_.yml b/docs/docs/dev/cli-reference/_category_.yml
new file mode 100644
index 0000000000..7752bd8f49
--- /dev/null
+++ b/docs/docs/dev/cli-reference/_category_.yml
@@ -0,0 +1,2 @@
+label: "CLI Guide"
+position: 1
diff --git a/docs/docs/dev/cli-reference/all-flags.md b/docs/docs/dev/cli-reference/all-flags.md
new file mode 100644
index 0000000000..3c43664b7e
--- /dev/null
+++ b/docs/docs/dev/cli-reference/all-flags.md
@@ -0,0 +1,2013 @@
+---
+sidebar_label: 'All commands'
+sidebar_position: 7
+---
+
+# CLI Commands overview
+
+:::info
+
+The following commands refer to bacalhau cli version `v1.2.0`.
+For installing or upgrading a client, follow the instructions in the [installation page](https://docs.bacalhau.org/getting-started/installation).
+Run `bacalhau version` in a terminal to check what version you have.
+
+:::
+
+Let’s run the `bacalhau -- help` command in the terminal to find out information about available commands and flags:
+
+```
+~$ bacalhau --help
+Compute over data
+
+Usage:
+  bacalhau [command]
+
+Available Commands:
+  agent       Commands to query agent information.
+  cancel      Cancel a previously submitted job
+  completion  Generate the autocompletion script for the specified shell
+  config      Interact with the bacalhau configuration system.
+  create      Create a job using a json or yaml file.
+  describe    Describe a job on the network
+  devstack    Start a cluster of bacalhau nodes for testing and development
+  docker      Run a docker job on the network (see run subcommand)
+  exec        Execute a specific job type
+  get         Get the results of a job
+  help        Help about any command
+  id          Show bacalhau node id info
+  job         Commands to submit, query and update jobs.
+  list        List jobs on the network
+  logs        Follow logs from a currently executing job
+  node        Commands to query and update nodes information.
+  serve       Start the bacalhau compute node
+  validate    validate a job using a json or yaml file.
+  version     Get the client and server version.
+  wasm        Run and prepare WASM jobs on the network
+
+Flags:
+      --api-host string         The host for the client and server to communicate on (via REST). Ignored if BACALHAU_API_HOST environment variable is set. (default "bootstrap.production.bacalhau.org")
+      --api-port int            The port for the client and server to communicate on (via REST). Ignored if BACALHAU_API_PORT environment variable is set. (default 1234)
+  -h, --help                    help for bacalhau
+      --log-mode logging-mode   Log format: 'default','station','json','combined','event' (default default)
+      --repo string             path to bacalhau repo (default "/home/user/.bacalhau")
+
+Use "bacalhau [command] --help" for more information about a command.
+```
+
+:::info
+Global Flags
+
+<details>
+  <summary>`--api-host string`</summary>
+  <div>
+    <div>Determines the host for RESTful communication between the client and server. This flag is ignored if the `BACALHAU_API_HOST` environment variable is set.  
+         Default: `bootstrap.production.bacalhau.org`</div>
+  </div>
+</details>
+<details>
+  <summary>`--api-port int`</summary>
+  <div>
+    <div>Determines the port for RESTful communication between the client and server. This flag is ignored if the `BACALHAU_API_PORT` environment variable is active.  
+         Default: `1234` </div>
+  </div>
+</details>
+<details>
+  <summary>`--log-mode logging-mode`</summary>
+  <div>
+    <div>Determines the preferred log format. Available log formats are: `default`, `station`, `json`, `combined`, `event`.  
+         Default: `default`</div>
+  </div>
+</details>
+<details>
+  <summary>`--repo string`</summary>
+  <div>
+    <div>Specifies the path to the bacalhau repository.  
+         Default: `$HOME/.bacalhau`</div>
+  </div>
+</details>
+:::
+
+
+## Agent
+
+The `bacalhau agent` command is a parent command that offers sub-commands to query information about the Bacalhau agent. This can be useful for debugging, monitoring, or managing the agent's behavior and health.
+
+Usage:
+
+```shell
+bacalhau agent [command]
+```
+Available Commands:
+
+### alive
+```shell
+bacalhau agent alive [flags]
+```
+The `bacalhau agent alive` command retrieves the agent's liveness and health information. This can be helpful to determine if the agent is running and healthy.
+
+```shell
+Flags:
+
+ -h, --help            help for alive
+     --output format   The output format for the command (one of ["json" "yaml"]) (default yaml)
+     --pretty          Pretty print the output. Only applies to json and yaml output formats.
+```
+
+:::info
+<details>
+  <summary>`--output format`</summary>
+  <div>
+    <div>Determines the format in which the output is displayed. Available formats include `JSON` and `YAML`.
+         Default: `yaml`</div>
+  </div>
+</details>
+<details>
+  <summary>`--pretty`</summary>
+  <div>
+    <div>Formats the output for enhanced readability. This flag is relevant only when using JSON or YAML output formats.</div>
+  </div>
+</details>
+:::
+
+#### Examples
+
+Let's have a look at the basic usage output:
+
+```shell
+bacalhau agent alive
+
+Expected Output:
+Status: OK
+```
+
+Compare the output in JSON format:
+
+```shell
+bacalhau agent alive --output json --pretty
+
+Expected Output:
+{
+  "Status": "OK"
+}
+```
+
+### node
+
+```shell
+bacalhau agent node [flags]
+```
+
+The `bacalhau agent node` command gathers the agent's node-related information. This might include details about the machine or environment where the agent is running, available resources, supported engines, etc.
+
+```shell
+Flags:
+  -h, --help            help for node
+      --output format   The output format for the command (one of ["json" "yaml"]) (default yaml)
+      --pretty          Pretty print the output. Only applies to json and yaml output formats.
+```
+
+#### Examples
+
+To retrieve Node Information in Default Format (YAML), run:
+
+```shell
+bacalhau agent node
+```
+
+To retrieve Node Information in JSON Format, run:
+
+```shell
+bacalhau agent node --output json
+```
+
+To retrieve Node Information in Pretty-printed JSON Format, run:
+
+```shell
+bacalhau agent node --output json --pretty
+```
+
+### version
+
+```shell
+bacalhau agent version [flags]
+```
+
+The `bacalhau agent version` command is used to obtain the version of the bacalhau agent.
+
+```shell
+ Flags:
+  -h, --help            help for version
+      --output format   The output format for the command (one of ["json" "yaml"])
+      --pretty          Pretty print the output. Only applies to json and yaml output formats.
+```
+
+#### Examples
+
+Let's have a look at the command execution in the terminal:
+
+```shell
+bacalhau agent version
+
+Expected Output:
+Bacalhau v1.2.0
+BuildDate 2023-12-11 18:46:13 +0000 UTC
+GitCommit 4252ba4406c40c3d01bdcf58709f8d7a705fdc75
+```
+To retrieve the agent version in JSON format, run:
+
+```shell
+bacalhau agent version --output json
+
+Expected Output:
+{"Major":"1","Minor":"2","GitVersion":"v1.2.0","GitCommit":"4252ba4406c40c3d01bdcf58709f8d7a705fdc75","BuildDate":"2023-12-11T18:46:13Z","GOOS":"linux","GOARCH":"amd64"}
+```
+
+To retrieve the agent version in Pretty-printed JSON format, run:
+
+```shell
+bacalhau agent version --output json --pretty
+
+Expected Output:
+{
+  "Major": "1",
+  "Minor": "2",
+  "GitVersion": "v1.2.0",
+  "GitCommit": "4252ba4406c40c3d01bdcf58709f8d7a705fdc75",
+  "BuildDate": "2023-12-11T18:46:13Z",
+  "GOOS": "linux",
+  "GOARCH": "amd64"
+}
+```
+
+## Cancel 
+
+The `bacalhau cancel` command cancels a job that was previously submitted and stops it running if it has not yet completed.
+
+Usage:
+
+```shell
+bacalhau cancel [id] [flags]
+```
+
+```shell
+Flags:
+  -h, --help    help for cancel
+      --quiet   Do not print anything to stdout or stderr
+```
+
+#### Examples 
+
+To cancel a previously submitted job, run:
+
+```shell
+ bacalhau cancel 51225160-807e-48b8-88c9-28311c7899e1
+```
+To cancel a job using a short ID, run:
+
+```shell
+ bacalhau cancel 51225160
+```
+
+## Completion
+
+The `bacalhau completion` command generates the autocompletion script for bacalhau for the specified shell.
+
+Usage:
+
+```shell
+bacalhau completion [command]
+```
+
+Available Commands:
+
+### bash
+```shell
+bacalhau completion bash [flags]
+```
+
+The `bacalhau completion bash` command generates the autocompletion script for bash.
+
+```shell
+Flags:
+  -h, --help              help for bash
+      --no-descriptions   disable completion descriptions
+```
+
+:::info
+This script depends on the 'bash-completion' package.
+If it is not installed already, you can install it via your OS's package manager.
+:::
+
+### fish
+
+```shell
+bacalhau completion fish [flags]
+```
+
+The `bacalhau completion fish` command generates the autocompletion script for the fish shell.
+
+```shell
+Flags:
+  -h, --help              help for fish
+      --no-descriptions   disable completion descriptions
+```
+:::info
+To load completions in your current shell session:  
+	`bacalhau completion fish | source`  
+To load completions for every new session, execute once:  
+	`bacalhau completion fish > ~/.config/fish/completions/bacalhau.fish`  
+You will need to start a new shell for this setup to take effect.
+:::
+
+
+### powershell
+
+```shell
+bacalhau completion powershell [flags]
+```
+The `bacalhau completion powershell` command generates the autocompletion script for powershell.
+
+```shell
+Flags:
+  -h, --help              help for powershell
+      --no-descriptions   disable completion descriptions
+```
+
+:::info
+To load completions in your current shell session:  
+	`bacalhau completion powershell | Out-String | Invoke-Expression`  
+To load completions for every new session, add the output of the above command
+to your powershell profile.
+:::
+
+### zsh
+
+```shell
+bacalhau completion zsh [flags]
+```
+The `bacalhau completion zsh` command generates the autocompletion script for the zsh shell.
+
+```shell
+Flags:
+  -h, --help              help for zsh
+      --no-descriptions   disable completion descriptions
+```
+
+:::info
+If shell completion is not already enabled in your environment you will need
+to enable it.  You can execute the following once:  
+	`echo "autoload -U compinit; compinit" >> ~/.zshrc`
+:::
+
+## Config
+
+The `bacalhau config` command is a parent command that offers sub-commands to modify and query information about the Bacalhau config. This can be useful for debugging, monitoring, or managing the nodes configuration.
+
+Usage:
+
+```shell
+bacalhau config [command]
+```
+
+Available Commands:
+
+### auto-resources
+```shell
+bacalhau config auto-resources [flags]
+```
+
+The `bacalhau config auto-resources` command automatically configures compute resource values in the bacalhau node's configuration file based on the hardware resources of the user's machine. This command streamlines the process of resource allocation for jobs, dynamically adjusting settings to align with the capabilities of the machine. It is designed to simplify the task of resource management, ensuring that the node operates efficiently and effectively within the hardware's limits.
+
+:::info
+The `bacalhau config auto-resources` command intelligently adjusts resource allocation settings based on the specific hardware configuration of your machine, promoting optimal utilization for bacalhau jobs. Due to the dynamic nature of this command, the specific values set in the configuration will vary depending on the available hardware resources of the machine in use. This functionality is particularly beneficial for users who seek to optimize their node's performance without the need for manual calculations of resource limits. It is important for users to understand that these settings will directly impact the number and types of jobs their node can manage at any given time, based on the machine's resource capacity.
+:::
+
+```shell
+Flags:
+      --default-job-percentage int   Percentage expressed as a number from 1 to 100 representing default per job amount of resources jobs will get when they don't specify any resource limits themselves (values over 100 will be rejected (default 75)
+  -h, --help                         help for auto-resources
+      --job-percentage int           Percentage expressed as a number from 1 to 100 representing per job amount of resource the system can be using at one time for a single job (values over 100 will be rejected) (default 75)
+      --queue-job-percentage int     Percentage expressed as a number from 1 to 100 representing the total amount of resource the system can queue at one time in aggregate for all jobs (values over 100 are accepted) (default 150)
+      --total-percentage int         Percentage expressed as a number from 1 to 100 representing total amount of resource the system can be using at one time in aggregate for all jobs (values over 100 will be rejected) (default 75)
+```
+
+#### Examples
+
+Ran on an Apple M1 Max with 10 Cores and 64GB RAM
+
+1. Basic Usage:
+
+```shell
+bacalhau config auto-resources
+```
+Config File:
+
+ ```yaml
+   node:
+       compute:
+           capacity:
+               defaultjobresourcelimits:
+                   cpu: 7500m
+                   disk: 568 GB
+                   gpu: "0"
+                   memory: 52 GB
+               jobresourcelimits:
+                   cpu: 7500m
+                   disk: 568 GB
+                   gpu: "0"
+                   memory: 52 GB
+               queueresourcelimits:
+                   cpu: 15000m
+                   disk: 1.1 TB
+                   gpu: "0"
+                   memory: 103 GB
+               totalresourcelimits:
+                   cpu: 7500m
+                   disk: 568 GB
+                   gpu: "0"
+                   memory: 52 GB
+   ```
+
+2. Queue 500% system resources:
+
+```shell
+bacalhau config auto-resources --queue-job-percentage=500
+```
+
+Config File:
+
+```yaml
+   node:
+       compute:
+           capacity:
+               defaultjobresourcelimits:
+                   cpu: 7500m
+                   disk: 568 GB
+                   gpu: "0"
+                   memory: 52 GB
+               jobresourcelimits:
+                   cpu: 7500m
+                   disk: 568 GB
+                   gpu: "0"
+                   memory: 52 GB
+               queueresourcelimits:
+                   cpu: 50000m
+                   disk: 3.8 TB
+                   gpu: "0"
+                   memory: 344 GB
+               totalresourcelimits:
+                   cpu: 7500m
+                   disk: 568 GB
+                   gpu: "0"
+                   memory: 52 GB
+   ```
+
+### default
+```shell
+bacalhau config default [flags]
+```
+
+The `bacalhau config default` command prints the default configuration of a bacalhau node to the standard output (stdout). This command is advantageous for users to view the baseline settings a bacalhau node will use in the absence of any user-defined configuration changes. It provides a clear view of the default operational parameters of the node, aiding users in understanding and customizing their configuration from a known baseline.
+
+:::info
+The output of this command shows the initial default settings for a new bacalhau node and is useful for understanding the foundational settings for customization. To apply these default settings, you can redirect the output to your configuration file using `bacalhau config default > ~/.bacalhau/config.yaml`, which overwrites your current configuration file with the default settings. However, if you wish to always use the latest default settings, especially if the defaults are updated over time, consider deleting your existing configuration file (e.g., `~/.bacalhau/config.yaml`). This approach ensures that your bacalhau node uses the most current defaults, circumventing potential discrepancies between the latest defaults and those captured in an older configuration file created with `bacalhau config default`.
+:::
+
+```shell
+Flags:
+  -h, --help          help for default
+      --path string   sets path dependent config fields (default $HOME/.bacalhau)
+```
+
+#### Examples
+
+```shell
+bacalhau config default > ~/.bacalhau/config.yaml
+```
+This command redirects the default configuration output directly into the bacalhau configuration file at `~/.bacalhau/config.yaml`, effectively resetting it to default settings.
+
+### list
+```shell
+bacalhau config list [flags]
+```
+The `bacalhau config list` command lists the configuration keys and values of the bacalhau node. This command is useful for understanding how configuration keys map to their respective values, aiding in the use of the bacalhau config set command.
+
+:::info
+Configuration values displayed by this command represent the settings that will be applied when the bacalhau node is next restarted. It is important to note that these values may not reflect the current operational configuration of an active bacalhau node. The displayed configuration is relevant and accurate for a node that is either not currently running or that has been restarted after the execution of this command.
+:::
+
+```shell
+Flags:
+  -h, --help            help for the list sub-command
+      --hide-header     do not print the column headers (default false)
+      --no-style        remove all styling from table output (default false)
+      --output format   The output format for the command (one of ["table" "csv" "json" "yaml"]) (default table)
+      --pretty          Pretty print the output. Only applies to json and yaml output formats (default true)
+      --wide            Print full values in the table results (default false)
+```
+
+#### Examples
+
+Basic Usage:
+
+```shell
+bacalhau config list
+
+KEY                                                             VALUE
+ metrics.eventtracerpath                                         /dev/null
+ metrics.libp2ptracerpath                                        /dev/null
+ node.allowlistedlocalpaths                                      []
+ node.bootstrapaddresses                                         [/ip4/35.245.161.250/tcp/1235/p2p/QmbxGS
+                                                                 sM6saCTyKkiWSxhJCt6Fgj7M9cns1vzYtfDbB5Ws
+                                                                 /ip4/34.86.254.26/tcp/1235/p2p/QmeXjeQDi
+                                                                 nxm7zRiEo8ekrJdbs7585BM6j7ZeLVFrA7GPe /i
+                                                                 p4/35.245.215.155/tcp/1235/p2p/QmPLPUUja
+                                                                 VE3wQNSSkxmYoaBPHVAWdjBjDYmMkWvtMZxAf]
+ node.clientapi.host                                             bootstrap.production.bacalhau.org
+ node.clientapi.port                                             1234
+ 
+ ...
+```
+
+### set
+```shell
+bacalhau config set <key> <value>
+```
+The `bacalhau config set` command sets a value in the bacalhau node's configuration file. This command is used to modify the configuration file that the bacalhau node will reference for its settings. Key names in the configuration are case-insensitive. Additionally, the command validates the value being set based on the type of the configuration key, ensuring that only appropriate and valid configurations are applied.
+
+:::info
+Changes made using this command will be applied to the configuration file, but they do not immediately affect the running configuration of an active bacalhau node. The modifications will take effect only after the node is restarted.
+:::
+
+```shell
+Flags:
+  -h, --help   help for set
+```
+#### Examples
+
+1. Configuring the Server API Port Value
+
+```shell
+bacalhau config set node.serverapi.port 9999
+```
+Verifying that the parameter was successfully set
+
+```shell
+bacalhau config list | grep serverapi.port
+ node.serverapi.port                                             9999                                     
+cat ~/.bacalhau/config.yaml
+node:
+    serverapi:
+        port: 9999
+```
+2. Configuring multiple values
+
+```shell
+bacalhau config set node.serverapi.port 9999
+bacalhau config set node.serverapi.host 0.0.0.0
+bacalhau config set node.loggingmode json
+```
+Verifying that the parameters were successfully set
+
+```shell
+cat ~/.bacalhau/config.yaml
+node:
+    loggingmode: json
+    serverapi:
+        host: 0.0.0.0
+        port: 9999
+```
+
+## Create
+
+The `bacalhau create` command is used to submit a job to the network in a declarative way by writing a jobspec instead of writing a command.
+JSON and YAML formats are accepted.
+
+Usage:
+
+```shell
+bacalhau create [flags]
+```
+
+```shell
+Flags:
+      --download                         Download the results and print stdout once the job has completed
+      --download-timeout-secs duration   Timeout duration for IPFS downloads. (default 5m0s)
+      --dry-run                          Do not submit the job, but instead print out what will be submitted
+  -f, --follow                           When specified will follow the output from the job as it runs
+  -g, --gettimeout int                   Timeout for getting the results of a job in --wait (default 10)
+  -h, --help                             help for create
+      --id-only                          Print out only the Job ID on successful submission.
+      --node-details                     Print out details of all nodes (overridden by --id-only).
+      --output-dir string                Directory to write the output to.
+      --raw                              Download raw result CIDs instead of merging multiple CIDs into a single result
+      --wait                             Wait for the job to finish. Use --wait=false to return as soon as the job is submitted. (default true)
+      --wait-timeout-secs int            When using --wait, how many seconds to wait for the job to complete before giving up. (default 600)
+```
+
+#### Examples
+
+1. To create a job using the data in `job.yaml`, run:
+```shell
+bacalhau create ./job.yaml
+```
+
+2. To create a new job from an already executed job, run:
+
+```shell
+bacalhau describe 6e51df50 | bacalhau create
+```
+
+### YAML format
+
+Let's have a look at a job example in **YAML format**:
+
+```yaml
+spec:
+    engine: Docker
+    verifier: Noop
+    publisher: IPFS
+    docker:
+        image: ubuntu
+        entryPoint:
+            - echo
+        parameters:
+            - Hello
+            - World
+    outputs:
+        - name: outputs
+          path: /outputs
+deal:
+    concurrency: 1
+```
+This example shows how a YAML file can be structured to describe a job and its parameters, which can then be used in Bacalhau to perform executions.
+
+### UCAN Invocation format
+
+You can also specify a job to run using a [UCAN Invocation](https://github.com/ucan-wg/invocation) object in JSON format. For the fields supported by Bacalhau, see the [IPLD schema](https://github.com/bacalhau-project/bacalhau/blob/main/pkg/model/schemas/bacalhau.ipldsch).
+
+There is no support for sharding, concurrency or minimum bidding for these jobs.
+
+#### Examples
+
+Refers to example models at balcalhau repository under [pkg/model/tasks](https://github.com/bacalhau-project/bacalhau/tree/main/pkg/model/tasks)
+
+An example UCAN Invocation that runs the same job as the above example would look like:
+
+```json
+{
+  "with": "ubuntu",
+  "do": "docker/run",
+  "inputs": {
+    "entrypoint": ["echo"],
+    "parameters": ["hello", "world"],
+    "workdir": "/",
+    "mounts": {},
+    "outputs": {
+      "/outputs": ""
+    }
+  },
+  "meta": {
+    "bacalhau/config": {
+      "verifier": 1,
+      "publisher": 4,
+      "annotations": ["hello"],
+      "resources": {
+        "cpu": 1,
+        "disk": 1073741824,
+        "memory": 1073741824,
+        "gpu": 0
+      },
+      "timeout": 300e9,
+      "dnt": false
+    }
+  }
+}
+```
+
+An example UCAN Invocation that runs a WebAssembly job might look like:
+
+```json
+{
+	"with": "ipfs://bafybeig7mdkzcgpacpozamv7yhhaelztfrnb6ozsupqqh7e5uyqdkijegi",
+	"do": "wasm32-wasi/run",
+	"inputs": {
+		"entrypoint": "_start",
+		"parameters": ["/inputs/data.tar.gz"],
+		"mounts": {
+			"/inputs": "https://www.example.com/data.tar.gz"
+		},
+		"outputs": {
+			"/outputs": ""
+		},
+		"env": {
+			"HELLO": "world"
+		}
+	},
+	"meta": {
+    }
+  }
+}
+```
+Using a UCAN Invocation object allows you to customize the parameters of job execution in Bacalhau in a more flexible and detailed way.
+
+## Describe
+
+The `bacalhau describe` command provides a full description of a job in YAML format. Short form and long form of the job id are accepted.  
+
+Usage:
+
+```shell
+bacalhau describe [id] [flags]
+```
+
+```shell
+Flags:
+  -h, --help             help for describe
+      --include-events   Include events in the description (could be noisy)
+      --json             Output description as JSON (if not included will be outputted as YAML by default)
+      --spec             Output Jobspec to stdout
+```
+
+#### Examples
+
+1. To describe a job with the full ID, run:
+
+```shell
+bacalhau describe e3f8c209-d683-4a41-b840-f09b88d087b9
+```
+2. To describe a job with the shortened ID, run:
+
+```shell
+bacalhau describe e3f8c209
+```
+3. To describe a job and include all server and local events, run:
+
+```shell
+bacalhau describe e3f8c209 --include-events  
+```
+
+## Devstack
+
+The `bacalhau devstack` command is used to start a cluster of nodes and run a job on them.
+
+Usage:
+
+```shell
+bacalhau devstack [flags]
+```
+```shell
+Flags:
+      --Noop                                             Use the noop executor for all jobs
+      --allow-listed-local-paths strings                 Local paths that are allowed to be mounted into jobs. Multiple paths can be specified by using this flag multiple times.
+      --autocert string                                  Specifies a host name for which ACME is used to obtain a TLS Certificate.
+                                                         Using this option results in the API serving over HTTPS
+      --bad-compute-actors int                           How many compute nodes should be bad actors
+      --bad-requester-actors int                         How many requester nodes should be bad actors
+      --compute-nodes int                                How many compute only nodes should be started in the cluster (default 3)
+      --cpu-profiling-file string                        File to save CPU profiling to
+      --default-job-execution-timeout duration           default value for the execution timeout this compute node will assign to jobs with no timeout requirement defined. (default 10m0s)
+      --disable-engine strings                           Engine types to disable
+      --disable-storage strings                          Storage types to disable
+      --disabled-publisher strings                       Publisher types to disable
+  -h, --help                                             help for devstack
+      --hybrid-nodes int                                 How many hybrid (requester and compute) nodes should be started in the cluster
+      --ignore-physical-resource-limits                  When set the compute node will ignore is physical resource limits
+      --job-execution-timeout-bypass-client-id strings   List of IDs of clients that are allowed to bypass the job execution timeout check
+      --job-negotiation-timeout duration                 Timeout value to hold a bid for a job. (default 3m0s)
+      --job-selection-accept-networked                   Accept jobs that require network access.
+      --job-selection-data-locality local|anywhere       Only accept jobs that reference data we have locally ("local") or anywhere ("anywhere"). (default Anywhere)
+      --job-selection-probe-exec string                  Use the result of a exec an external program to decide if we should take on the job.
+      --job-selection-probe-http string                  Use the result of a HTTP POST to decide if we should take on the job.
+      --job-selection-reject-stateless                   Reject jobs that don't specify any data.
+      --limit-job-cpu string                             Job CPU core limit to run all jobs (e.g. 500m, 2, 8).
+      --limit-job-gpu string                             Job GPU limit to run all jobs (e.g. 1, 2, or 8).
+      --limit-job-memory string                          Job Memory limit to run all jobs  (e.g. 500Mb, 2Gb, 8Gb).
+      --limit-total-cpu string                           Total CPU core limit to run all jobs (e.g. 500m, 2, 8).
+      --limit-total-gpu string                           Total GPU limit to run all jobs (e.g. 1, 2, or 8).
+      --limit-total-memory string                        Total Memory limit to run all jobs  (e.g. 500Mb, 2Gb, 8Gb).
+      --max-job-execution-timeout duration               The maximum execution timeout this compute node supports. Jobs with higher timeout requirements will not be bid on. (default 2562047h47m16s)
+      --memory-profiling-file string                     File to save memory profiling to
+      --min-job-execution-timeout duration               The minimum execution timeout this compute node supports. Jobs with lower timeout requirements will not be bid on. (default 500ms)
+      --peer string                                      Connect node 0 to another network node
+      --pluggable-executors                              Will use pluggable executors when set to true
+      --public-ipfs                                      Connect devstack to public IPFS
+      --requester-nodes int                              How many requester only nodes should be started in the cluster (default 1)
+      --stack-repo string                                Folder to act as the devstack configuration repo
+      --tlscert string                                   Specifies a TLS certificate file to be used by the requester node
+      --tlskey string                                    Specifies a TLS key file matching the certificate to be used by the requester node
+```
+#### Examples
+
+1. To create a devstack cluster with a single requester node and 3 compute nodes (default values), run:
+
+```shell
+bacalhau devstack
+```
+2. To create a devstack cluster with 2 requester nodes and 10 compute nodes, run:
+
+```shell
+bacalhau devstack  --requester-nodes 2 --compute-nodes 10
+```
+3. To create a devstack cluster with a single hybrid (requester and compute) node, run:
+
+```shell
+bacalhau devstack  --requester-nodes 0 --compute-nodes 0 --hybrid-nodes 1
+```
+4. To run a devstack and create (or use) the config repo in a specific folder, run:
+
+```shell
+bacalhau devstack  --stack-repo ./my-devstack-configuration
+```
+
+## Docker run
+
+The `bacalhau docker run` command runs a job using the Docker executor on the node.
+
+Usage:
+
+```shell
+bacalhau docker run [flags] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]
+```
+```shell
+Flags:
+      --concurrency int                  How many nodes should run the job (default 1)
+      --cpu string                       Job CPU cores (e.g. 500m, 2, 8).
+      --disk string                      Job Disk requirement (e.g. 500Gb, 2Tb, 8Tb).
+      --do-not-track                     When true the job will not be tracked(?) TODO BETTER DEFINITION
+      --domain stringArray               Domain(s) that the job needs to access (for HTTP networking)
+      --download                         Should we download the results once the job is complete?
+      --download-timeout-secs duration   Timeout duration for IPFS downloads. (default 5m0s)
+      --dry-run                          Do not submit the job, but instead print out what will be submitted
+      --entrypoint strings               Override the default ENTRYPOINT of the image
+  -e, --env strings                      The environment variables to supply to the job (e.g. --env FOO=bar --env BAR=baz)
+  -f, --follow                           When specified will follow the output from the job as it runs
+  -g, --gettimeout int                   Timeout for getting the results of a job in --wait (default 10)
+      --gpu string                       Job GPU requirement (e.g. 1, 2, 8).
+  -h, --help                             help for run
+      --id-only                          Print out only the Job ID on successful submission.
+  -i, --input storage                    Mount URIs as inputs to the job. Can be specified multiple times. Format: src=URI,dst=PATH[,opt=key=value]
+                                         Examples:
+                                         # Mount IPFS CID to /inputs directory
+                                         -i ipfs://QmeZRGhe4PmjctYVSVHuEiA9oSXnqmYa4kQubSHgWbjv72
+                                         # Mount S3 object to a specific path
+                                         -i s3://bucket/key,dst=/my/input/path
+                                         # Mount S3 object with specific endpoint and region
+                                         -i src=s3://bucket/key,dst=/my/input/path,opt=endpoint=https://s3.example.com,opt=region=us-east-1
+      --ipfs-connect string              The ipfs host multiaddress to connect to, otherwise an in-process IPFS node will be created if not set.
+      --ipfs-serve-path string           path local Ipfs node will persist data to
+      --ipfs-swarm-addrs strings         IPFS multiaddress to connect the in-process IPFS node to - cannot be used with --ipfs-connect. (default [/ip4/35.245.161.250/tcp/4001/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/35.245.161.250/udp/4001/quic/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/34.86.254.26/tcp/4001/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/34.86.254.26/udp/4001/quic/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/35.245.215.155/tcp/4001/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/35.245.215.155/udp/4001/quic/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/34.145.201.224/tcp/4001/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/34.145.201.224/udp/4001/quic/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/35.245.41.51/tcp/4001/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa,/ip4/35.245.41.51/udp/4001/quic/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa])
+      --ipfs-swarm-key string            Optional IPFS swarm key required to connect to a private IPFS swarm
+  -l, --labels strings                   List of labels for the job. Enter multiple in the format '-l a -l 2'. All characters not matching /a-zA-Z0-9_:|-/ and all emojis will be stripped.
+      --memory string                    Job Memory requirement (e.g. 500Mb, 2Gb, 8Gb).
+      --network network-type             Networking capability required by the job. None, HTTP, or Full (default None)
+      --node-details                     Print out details of all nodes (overridden by --id-only).
+  -o, --output strings                   name:path of the output data volumes. 'outputs:/outputs' is always added unless '/outputs' is mapped to a different name. (default [outputs:/outputs])
+      --output-dir string                Directory to write the output to.
+      --private-internal-ipfs            Whether the in-process IPFS node should auto-discover other nodes, including the public IPFS network - cannot be used with --ipfs-connect. Use "--private-internal-ipfs=false" to disable. To persist a local Ipfs node, set BACALHAU_SERVE_IPFS_PATH to a valid path. (default true)
+  -p, --publisher publisher              Where to publish the result of the job (default ipfs)
+      --raw                              Download raw result CIDs instead of merging multiple CIDs into a single result
+  -s, --selector string                  Selector (label query) to filter nodes on which this job can be executed, supports '=', '==', and '!='.(e.g. -s key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints.
+      --target all|any                   Whether to target the minimum number of matching nodes ("any") (default) or all matching nodes ("all") (default any)
+      --timeout int                      Job execution timeout in seconds (e.g. 300 for 5 minutes)
+      --wait                             Wait for the job to finish. Use --wait=false to return as soon as the job is submitted. (default true)
+      --wait-timeout-secs int            When using --wait, how many seconds to wait for the job to complete before giving up. (default 600)
+  -w, --workdir string                   Working directory inside the container. Overrides the working directory shipped with the image (e.g. via WORKDIR in Dockerfile).
+```
+#### Examples
+
+1. Let's run a Docker job, using the image `dpokidov/imagemagick`, with a CID mounted at `/input_images` and an output volume mounted at `/outputs` in the container. All flags after the `--` are passed directly into the container for execution:
+
+```shell
+bacalhau docker run \
+  -i src=ipfs://QmeZRGhe4PmjctYVSVHuEiA9oSXnqmYa4kQubSHgWbjv72,dst=/input_images \
+  dpokidov/imagemagick:7.1.0-47-ubuntu \
+  -- magick mogrify -resize 100x100 -quality 100 -path /outputs '/input_images/*.jpg'
+```
+This command allows you to start a job in a Docker container using the specified image, mount an external CID resource from IPFS inside the container to handle images, and execute a command inside the container to process files. 
+
+2. To check the job specification before submitting it to the bacalhau network, run:
+
+```shell
+bacalhau docker run --dry-run ubuntu echo hello
+```
+The command does not run the job itself, but only displays information about how it would be run so you can make sure that all job parameters and commands are correctly specified before sending it to the Bacalhau network for execution
+
+3. To save the job specification to a YAML file, run:
+
+```shell
+bacalhau docker run --dry-run ubuntu echo hello > job.yaml
+```
+
+4. To specify an image tag (default is `latest` - using a specific tag other than `latest` is recommended for reproducibility), run:
+
+```shell
+bacalhau docker run ubuntu:bionic echo hello
+```
+
+5. To specify an image digest, run:
+
+```shell
+bacalhau docker run ubuntu@sha256:35b4f89ec2ee42e7e12db3d107fe6a487137650a2af379bbd49165a1494246ea echo hello
+```
+The command starts an Ubuntu image container using a specific version of the image identified by its SHA256 hash. This ensures the accuracy of the image source, independent of its tag and possible future changes, since the image digest remains constant for a particular version.
+
+## Exec
+
+The `bacalhau exec` command is used to execute a specific job type.
+
+Usage:
+
+```shell
+bacalhau exec [jobtype] [flags]
+```
+
+```shell
+Flags:
+      --code string             Specifies the file, or directory of code to send with the request
+      --do-not-track            When true the job will not be tracked(?) TODO BETTER DEFINITION
+      --dry-run                 Do not submit the job, but instead print out what will be submitted
+  -e, --env strings             The environment variables to supply to the job (e.g. --env FOO=bar --env BAR=baz)
+  -f, --follow                  When specified will follow the output from the job as it runs
+  -h, --help                    help for exec
+      --id-only                 Print out only the Job ID on successful submission.
+  -i, --input storage           Mount URIs as inputs to the job. Can be specified multiple times. Format: src=URI,dst=PATH[,opt=key=value]
+                                Examples:
+                                # Mount IPFS CID to /inputs directory
+                                -i ipfs://QmeZRGhe4PmjctYVSVHuEiA9oSXnqmYa4kQubSHgWbjv72
+                                # Mount S3 object to a specific path
+                                -i s3://bucket/key,dst=/my/input/path
+                                # Mount S3 object with specific endpoint and region
+                                -i src=s3://bucket/key,dst=/my/input/path,opt=endpoint=https://s3.example.com,opt=region=us-east-1
+  -l, --labels strings          List of labels for the job. Enter multiple in the format '-l a -l 2'. All characters not matching /a-zA-Z0-9_:|-/ and all emojis will be stripped.
+      --node-details            Print out details of all nodes (overridden by --id-only).
+  -o, --output strings          name:path of the output data volumes. 'outputs:/outputs' is always added unless '/outputs' is mapped to a different name. (default [outputs:/outputs])
+  -p, --publisher publisher     Where to publish the result of the job (default ipfs)
+  -s, --selector string         Selector (label query) to filter nodes on which this job can be executed, supports '=', '==', and '!='.(e.g. -s key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints.
+      --timeout int             Job execution timeout in seconds (e.g. 300 for 5 minutes)
+      --wait                    Wait for the job to finish. Use --wait=false to return as soon as the job is submitted. (default true)
+      --wait-timeout-secs int   When using --wait, how many seconds to wait for the job to complete before giving up. (default 600)
+```
+
+#### Examples
+
+1. To execute the `app.py` script with Python, run:
+
+```shell
+bacalhau exec python app.py
+```
+
+2. To run a duckdb query against a `CSV` file:
+
+```shell
+bacalhau exec -i src=...,dst=/inputs/data.csv duckdb "select * from /inputs/data.csv"e
+```
+
+## Get
+
+The `bacalhau get` command is used to get the results of the job, including stdout and stderr.
+
+Usage:
+
+```shell
+ bacalhau get [id] [flags]
+```
+
+```shell
+Flags:
+      --download-timeout-secs duration   Timeout duration for IPFS downloads. (default 5m0s)
+  -h, --help                             help for get
+      --ipfs-connect string              The ipfs host multiaddress to connect to, otherwise an in-process IPFS node will be created if not set.
+      --ipfs-serve-path string           path local Ipfs node will persist data to
+      --ipfs-swarm-addrs strings         IPFS multiaddress to connect the in-process IPFS node to - cannot be used with --ipfs-connect. (default [/ip4/35.245.161.250/tcp/4001/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/35.245.161.250/udp/4001/quic/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/34.86.254.26/tcp/4001/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/34.86.254.26/udp/4001/quic/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/35.245.215.155/tcp/4001/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/35.245.215.155/udp/4001/quic/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/34.145.201.224/tcp/4001/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/34.145.201.224/udp/4001/quic/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/35.245.41.51/tcp/4001/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa,/ip4/35.245.41.51/udp/4001/quic/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa])
+      --ipfs-swarm-key string            Optional IPFS swarm key required to connect to a private IPFS swarm
+      --output-dir string                Directory to write the output to.
+      --private-internal-ipfs            Whether the in-process IPFS node should auto-discover other nodes, including the public IPFS network - cannot be used with --ipfs-connect. Use "--private-internal-ipfs=false" to disable. To persist a local Ipfs node, set BACALHAU_SERVE_IPFS_PATH to a valid path. (default true)
+      --raw                              Download raw result CIDs instead of merging multiple CIDs into a single result
+```
+
+#### Examples
+
+1. To get the results of a job, run:
+
+```shell
+bacalhau get 51225160-807e-48b8-88c9-28311c7899e1
+```
+
+2. To get the results of a job, using a short ID, run:
+
+```shell
+bacalhau get 51225160
+```
+
+## Help
+
+The `bacalhau help` command provides help for any command in the application. 
+
+Usage:
+
+```shell
+bacalhau help [command] [flags]
+```
+```shell
+Flags:
+  -h, --help   help for help
+```
+
+## ID
+
+The `bacalhau id` command shows bacalhau node id info.
+
+Usage:
+
+```shell
+bacalhau id [flags]
+```
+
+```shell
+Flags:
+  -h, --help             help for id
+      --hide-header      do not print the column headers.
+      --no-style         remove all styling from table output.
+      --output format    The output format for the command (one of ["table" "csv" "json" "yaml"]) (default json)
+      --peer string      A comma-separated list of libp2p multiaddress to connect to. Use "none" to avoid connecting to any peer, "env" to connect to the default peer list of your active environment (see BACALHAU_ENVIRONMENT env var). (default "none")
+      --pretty           Pretty print the output. Only applies to json and yaml output formats.
+      --swarm-port int   The port to listen on for swarm connections. (default 1235)
+      --wide             Print full values in the table results
+```
+
+## Job
+
+The `bacalhau job` command provides a suite of sub-commands to submit, query, and manage jobs within Bacalhau. Users can deploy jobs, obtain job details, track execution logs, and more.
+
+Usage:
+```shell
+ bacalhau job [command]
+```
+
+Available Commands:
+
+### describe 
+
+```shell
+bacalhau job describe [id] [flags]
+```
+The `bacalhau job describe` command provides a detailed description of a specific job in YAML format. This description can be particularly useful when wanting to understand the attributes and current status of a specific job. To list all available jobs, the `bacalhau job list` command can be used.
+
+```shell
+Flags:
+  -h, --help            help for describe
+      --output format   The output format for the command (one of ["json" "yaml"]) (default yaml)
+      --pretty          Pretty print the output. Only applies to json and yaml output formats.
+```
+#### Examples
+
+1. To describe a job with the full ID, run:
+
+```shell
+bacalhau job describe j-e3f8c209-d683-4a41-b840-f09b88d087b9
+```
+2. To describe a job with the shortened ID, run:
+
+```shell
+bacalhau job describe j-e3f8c209
+```
+3. To describe a job with json output, run:
+
+```shell
+bacalhau job describe j-e3f8c209 --output json --pretty
+```
+
+### executions
+
+```shell
+bacalhau job executions [id] [flags]
+```
+The `bacalhau job executions` command retrieves a list of executions for a specific job based on its ID. This can be essential when tracking the various runs and their respective states for a particular job.
+
+```shell
+Flags:
+  -h, --help                help for executions
+      --hide-header         do not print the column headers when displaying the results.
+      --limit uint32        Limit the number of results returned (default 20)
+      --next-token string   Uses the specified token for pagination. Useful for fetching the next set of results.
+      --no-style            remove all styling from table output displaying raw data.
+      --order-by string     Order results based on a specific field. Valid fields are: modify_time, create_time, id, state
+      --order-reversed      Reverse the order of the results. Useful in conjunction with --order-by.
+      --output format       Specify the output format for the command (one of ["table" "csv" "json" "yaml"]) (default table)
+      --pretty              Pretty print the output. Only applies to json and yaml output formats.
+      --wide                Print full values in the table result without truncating any information.
+```
+#### Examples
+
+1. To get all executions for a specific job, run:
+
+```shell
+bacalhau job executions j-e3f8c209-d683-4a41-b840-f09b88d087b9
+
+Expected Output:
+CREATED   MODIFIED  ID          NODE ID   REV.  COMPUTE    DESIRED  COMMENT
+                                                STATE      STATE
+16:46:03  16:46:04  e-99362435  QmTSJgdN  6     Completed  Stopped
+16:46:03  16:46:04  e-75dd20bb  QmXRdLru  6     Completed  Stopped
+16:46:03  16:46:04  e-03870df5  QmVXwmdZ  6     Completed  Stopped
+```
+
+2. To get executions with YAML output, run: 
+
+```shell
+bacalhau job executions j-4faae6f0-17b3-4a6d-991e-c82a677c7228 --output yaml
+
+Expected Output:
+- AllocatedResources:
+    Tasks: {}
+  ComputeState:
+    StateType: 7
+  CreateTime: 1704468726831851981
+  DesiredState:
+    Message: execution completed
+    StateType: 2
+    ...
+```
+
+### history
+
+```shell
+bacalhau job history [id] [flags]
+```
+The `bacalhau job history` command lists the history events of a specific job based on its ID. This feature allows users to track changes, executions, and other significant milestones associated with a particular job.
+
+```shell
+Flags:
+      --event-type string     The type of history events to return. One of: all, job, execution (default "all")
+      --execution-id string   Filters results by a specific execution ID.
+  -h, --help                  help for history
+      --hide-header           do not print the column headers.
+      --limit uint32          Limit the number of results returned
+      --next-token string     Uses the specified token for pagination.
+      --no-style              remove all styling from table output.
+      --node-id string        Filters the results by a specific node ID.
+      --order-by string       Order results by a field
+      --order-reversed        Reverse the order of the results
+      --output format         The output format for the command (one of ["table" "csv" "json" "yaml"]) (default table)
+      --pretty                Pretty print the output. Only applies to json and yaml output formats.
+      --wide                  Print full values in the table results without truncating any information.
+```
+
+#### Examples
+
+1. To retrieve the history of a specific job, run:
+
+```shell
+bacalhau job history j-4faae6f0-17b3-4a6d-991e-c82a677c7228
+
+Expected Output:
+TIME      LEVEL           EXEC. ID    NODE ID   REV.  PREVIOUS STATE     NEW STATE          COMMENT
+ 15:32:06  JobLevel                              1     Pending            Pending            Job created
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  1     New                New
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  2     New                AskForBid
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  3     AskForBid          AskForBidAccepted
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  4     AskForBidAccepted  AskForBidAccepted
+ 15:32:06  JobLevel                              2     Pending            Running
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  5     AskForBidAccepted  BidAccepted
+ 15:32:07  ExecutionLevel  e-228bbb88  QmeXjeQD  6     BidAccepted        Completed
+ 15:32:07  JobLevel                              3     Running            Completed
+```
+
+2. To filter the history by event type, run:
+
+```shell
+bacalhau job history j-6f2bf0ea-ebcd-4490-899a-9de9d8d95881 --event-type job
+
+Expected Output:
+TIME      LEVEL     EXEC. ID  NODE ID  REV.  PREVIOUS STATE  NEW STATE  COMMENT
+16:46:03  JobLevel                     1     Pending         Pending    Job created
+16:46:04  JobLevel                     2     Pending         Completed
+```
+
+3. To filter the history by execution ID, run:
+
+```shell
+bacalhau job history j-4faae6f0-17b3-4a6d-991e-c82a677c7228 --execution-id e-228bbb88
+
+Expected Output:
+ TIME      LEVEL           EXEC. ID    NODE ID   REV.  PREVIOUS STATE     NEW STATE          COMMENT
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  1     New                New
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  2     New                AskForBid
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  3     AskForBid          AskForBidAccepted
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  4     AskForBidAccepted  AskForBidAccepted
+ 15:32:06  ExecutionLevel  e-228bbb88  QmeXjeQD  5     AskForBidAccepted  BidAccepted
+ 15:32:07  ExecutionLevel  e-228bbb88  QmeXjeQD  6     BidAccepted        Completed
+```
+
+### list
+
+```shell
+bacalhau job list [flags]
+```
+The `bacalhau job list` command provides a listing of all submitted jobs. This command offers an overview of all tasks and processes registered in the system, allowing users to monitor and manage their jobs effectively.
+
+```shell
+Flags:
+  -h, --help                help for list
+      --hide-header         do not print the column headers.
+      --labels string       Filter nodes by labels. See https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ for more information. (default "bacalhau_canary != true")
+      --limit uint32        Limit the number of results returned (default 10)
+      --next-token string   Uses the specified token for pagination.
+      --no-style            remove all styling from table output.
+      --order-by string     Order results by a field. Valid fields are: id, created_at
+      --order-reversed      Reverse the order of the results
+      --output format       The output format for the command (one of ["table" "csv" "json" "yaml"]) (default table)
+      --pretty              Pretty print the output. Only applies to json and yaml output formats.
+      --wide                Print full values in the table results without truncating any information.
+```
+
+#### Examples
+
+1. To list all jobs, run:
+
+```shell
+bacalhau job list
+
+Expected Output:
+CREATED   ID          JOB     TYPE   STATE
+ 01:10:20  fd7dcb28    docker  batch  Completed
+ 15:10:24  2e2dd082    docker  batch  Completed
+ 03:05:23  56c2d0ef    docker  batch  Completed
+ 01:25:57  d32e92cc    docker  batch  Completed
+ 12:30:57  fa01c947    docker  batch  Completed
+ 09:01:04  da9d8f5a    docker  batch  Completed
+ 14:51:13  093a7746    docker  batch  Completed
+ 13:56:05  379cdbf7    docker  batch  Completed
+ 04:01:13  4a72e10b    docker  batch  Completed
+ 09:02:51  a50b8ea3    docker  batch  Completed
+```
+2. To limit the list to the last 2 jobs, run:
+
+```shell
+bacalhau job list --limit 2
+
+Expected Output:
+ CREATED   ID          JOB     TYPE   STATE
+ 09:45:57  437728bf    docker  batch  Completed
+ 09:55:42  523b6447    docker  batch  Completed
+```
+
+3. To order the list by creation date in descending order, run:
+
+```shell
+ bacalhau job list --order-by created_at --order-reversed
+
+Expected Output:
+ CREATED   ID          JOB     TYPE   STATE
+ 16:51:13  3490b0bd    docker  batch  Completed
+ 16:51:04  3b02b691    docker  batch  Completed
+ 16:51:00  c5b5b8b4    docker  batch  Completed
+ 16:50:57  8c062944    docker  batch  Completed
+ 16:50:51  062517b2    docker  batch  Completed
+ 16:50:45  4e0728a6    docker  batch  Completed
+ 16:50:42  50c27dd0    docker  batch  Completed
+ 16:50:23  8be21cd0    docker  batch  Completed
+ 16:50:20  162bb215    docker  batch  Completed
+ 16:47:51  33e98bd9    docker  batch  Completed
+```
+4. To filter the jobs by specific labels (`region in (us-east-1, us-east-2)` and `env = prod`), run:
+
+```shell
+bacalhau job list --labels "region in (us-east-1, us-east-2),env = prod"
+```
+
+5. To get the list in JSON format with pretty printing, run:
+
+```shell
+bacalhau job list --limit 1 --output json --pretty
+
+[
+  {
+    "ID": "3ecf5eac-2250-4444-9bd1-455c6b6e5dd2",
+    "Name": "3ecf5eac-2250-4444-9bd1-455c6b6e5dd2",
+    "Namespace": "eeb90e1730b2240b3e16e70d383fb9c6cbe40969e8b7ff71e805edeffff3d81d",
+    "Type": "batch",
+    "Priority": 0,
+    "Count": 1,
+    "Constraints": [
+      {
+        "Key": "favour_owner",
+        "Operator": "!=",
+        "Values": [
+          "bacalhau"
+        ]
+      }
+    ],
+    "Meta":
+    ...
+```
+### logs
+
+```shell
+bacalhau job logs [id] [flags]
+```
+The `bacalhau job logs` command allows users to retrieve logs from a job that has been previously submitted. This command is useful for tracking and debugging the progress and state of a running or completed job.
+
+```shell
+  Flags:
+  -f, --follow   Follow the logs in real-time after retrieving the current logs.
+  -h, --help     help for logs
+```
+#### Examples
+
+1. To display Logs for a Previously Submitted Job using Full Job ID, run:
+
+```shell
+bacalhau job logs j-51225160-807e-48b8-88c9-28311c7899e1
+
+Expected Output:
+[2023-09-24 09:01:32] INFO - Application started successfully.
+[2023-09-24 09:01:33] DEBUG - Initializing database connections.
+[2023-09-24 09:01:35] WARN - API rate limit approaching.
+[2023-09-24 09:02:01] ERROR - Failed to retrieve data from endpoint: /api/v1/data.
+[2023-09-24 09:05:00] INFO - Data sync completed with 4500 new records.
+```
+
+2. To follow Logs in Real-Time, run:
+
+```shell
+bacalhau job logs --follow j-51225160-807e-48b8-88c9-28311c7899e1
+
+Expected Output:
+[2023-09-24 11:30:02] INFO - User 'john_doe' logged in successfully.
+[2023-09-24 11:30:15] DEBUG - Fetching data from cache for key: userSettings_john_doe.
+[2023-09-24 11:31:05] WARN - High memory usage detected: 85% of allocated resources.
+... [Logs continue to appear in real-time] ...
+```
+
+### run
+
+```shell
+bacalhau job run [flags]
+```
+
+The `bacalhau job run` command facilitates the initiation of a job from a file or directly from the standard input (stdin). The command supports both JSON and YAML data formats. This command is particularly useful for quickly executing a job without the need for manual configurations.
+
+```shell
+Flags:
+      --dry-run                        Do not submit the job, but instead print out what will be submitted
+  -f, --follow                         When specified will continuously display the output from the job as it runs
+  -h, --help                           help for run
+      --id-only                        Print out only the Job ID on successful submission.
+      --no-template                    Disable the templating feature. When this flag is set, the job spec will be used as-is, without any placeholder replacements
+      --node-details                   Print out details of all nodes (Note that this flag is overridden if --id-only is provided).
+      --show-warnings                  Shows any warnings that occur during the job submission
+  -E, --template-envs string           Specify a regular expression pattern for selecting environment variables to be included as template variables in the job spec.
+                                       e.g. --template-envs ".*" will include all environment variables.
+  -V, --template-vars stringToString   Replace a placeholder in the job spec with a value. e.g. --template-vars foo=bar
+      --wait                           Wait for the job to finish. Use --wait=false to return as soon as the job is submitted. (default true)
+      --wait-timeout-secs int          If --wait is provided, this flag sets the maximum time (in seconds) the command will wait for the job to finish before it terminates. (default 600)
+```
+#### Examples
+
+A sample job used in the following examples is provided below:
+```bash
+cat job.yaml
+```
+
+```yaml
+name: A Simple Docker Job
+type: batch
+count: 1
+tasks:
+  - name: My main task
+    engine:
+      type: docker
+      params:
+        Image: ubuntu:latest
+        Entrypoint:
+          - /bin/bash
+        Parameters:
+          - -c
+          - echo Hello Bacalhau!
+```
+
+This configuration describes a batch job that runs a Docker task. It utilizes the `ubuntu:latest` image and executes the `echo Hello Bacalhau!` command.
+
+1. To run a job with a configuration provided in a `job.yaml` file:
+
+ ```bash
+ bacalhau job run job.yaml
+ 
+ Expected Output:
+ Job successfully submitted. Job ID: j-2d0f513a-9eb1-49c2-8bc8-246c6fb41520
+   Checking job status... (Enter Ctrl+C to exit at any time, your job will continue running):
+
+	Communicating with the network  ................  done ✅  0.1s
+	               Job in progress  ................  done ✅  0.6s
+
+   To get more details about the run, execute:
+	bacalhau job describe j-2d0f513a-9eb1-49c2-8bc8-246c6fb41520
+
+   To get more details about the run executions, execute:
+	bacalhau job executions j-2d0f513a-9eb1-49c2-8bc8-246c6fb41520
+ ```
+
+2. To run a Job and follow its Logs:
+
+```shell
+bacalhau job run job.yaml --follow
+
+Expected Output:
+Job successfully submitted. Job ID: j-b89df816-7564-4f04-b270-e6cda89eda72
+Waiting for logs... (Enter Ctrl+C to exit at any time, your job will continue running):
+
+Hello Bacalhau!
+```
+
+3. To run a Job Without Waiting:
+
+```shell
+bacalhau job run job.yaml --wait=false
+
+Expected Output:
+j-3fd396b3-e92e-42ca-bd87-0dc9eb15e6f9
+```
+
+4. To fetch Only the Job ID Upon Submission:
+
+```shell
+bacalhau job run job.yaml --id-only
+
+Expected Output:
+j-5976ffb6-3465-4fec-8b3b-2c822cbaf417
+```
+
+5. To fetch Only the Job ID and Wait for Completion:
+
+```shell
+bacalhau job run job.yaml --id-only --wait
+
+Expected Output:
+j-293f1302-3298-4aca-b06d-33fd1e3f9d2c
+```
+
+6. To run a Job with Node Details:
+
+```shell
+bacalhau job run job.yaml --node-details
+
+Expected Output:
+Job successfully submitted. Job ID: j-3634acc2-c92c-494d-9413-ddd8629d0e74
+Checking job status... (Enter Ctrl+C to exit at any time, your job will continue running):
+	Communicating with the network  ................  done ✅  0.1s
+	               Job in progress  ................  done ✅  0.7s
+Job Results By Node:
+• Node QmSD38wH:
+	Hello Bacalhau!
+	
+To get more details about the run, execute:
+	bacalhau job describe j-3634acc2-c92c-494d-9413-ddd8629d0e74
+To get more details about the run executions, execute:
+	bacalhau job executions j-3634acc2-c92c-494d-9413-ddd8629d0e74
+```
+7. To rerun a previously submitting job:
+
+```shell
+bacalhau job describe j-3634acc2-c92c-494d-9413-ddd8629d0e74 | bacalhau job run
+
+Expected Output:
+Reading from /dev/stdin; send Ctrl-d to stop.Job successfully submitted. Job ID: j-c3441e11-0620-480f-b5d7-a35727398d9a
+Checking job status... (Enter Ctrl+C to exit at any time, your job will continue running):
+	Communicating with the network  ................  done ✅  0.2s
+	               Job in progress  ................  done ✅  0.7s
+To get more details about the run, execute:
+	bacalhau job describe j-c3441e11-0620-480f-b5d7-a35727398d9a
+To get more details about the run executions, execute:
+	bacalhau job executions j-c3441e11-0620-480f-b5d7-a35727398d9a
+```
+
+### stop
+
+```shell
+bacalhau job stop [id] [flags]
+```
+
+The `bacalhau job stop` command allows users to terminate a previously submitted job. This is useful in scenarios where there's a need to halt a running job, perhaps due to misconfiguration or changed priorities.
+
+```shell
+Flags:
+  -h, --help    help for stop
+      --quiet   Do not print anything to stdout or stderr
+```
+
+#### Examples
+
+1. To Stop a Specific Job, run:
+
+```shell
+bacalhau job stop j-10eb97de-14cd-4db4-96ec-561bb943309a
+
+Expected Output:
+Checking job status
+
+   	Connecting to network  ................  done ✅  0.0s
+   	  Verifying job state  ................  done ✅  0.2s
+   	          Stopping job ................  done ✅  0.1s
+
+   Job stop successfully submitted with evaluation ID: 397fd425-8b1a-491e-952a-0632492e7ece
+```
+
+2. To terminate a job without seeing any verbose feedback or messages, run:
+
+```shell
+bacalhau job stop j-63b5ec0c-b5bf-4398-a152-b46c07abe52a --quiet
+
+Expected Output:
+[No output displayed as the operation is run quietly.]
+```
+
+## List
+
+The `bacalhau list` command lists jobs on the network.
+
+Usage:
+```shell
+bacalhau list [flags]
+```
+
+```shell
+Flags:
+      --all                   Fetch all jobs from the network (default is to filter those belonging to the user). This option may take a long time to return, please use with caution.
+      --exclude-tag strings   Only return jobs that do not have the passed tag in their annotations (default [canary])
+  -h, --help                  help for list
+      --hide-header           do not print the column headers.
+      --id-filter string      filter by Job List to IDs matching substring.
+      --include-tag strings   Only return jobs that have the passed tag in their annotations
+      --no-style              remove all styling from table output.
+  -n, --number int            print the first NUM jobs instead of the first 10. (default 10)
+      --output format         The output format for the command (one of ["table" "csv" "json" "yaml"]) (default table)
+      --pretty                Pretty print the output. Only applies to json and yaml output formats.
+      --reverse               reverse order of table - for time sorting, this will be newest first. Use '--reverse=false' to sort oldest first (single quotes are required). (default true)
+      --sort-by Column        sort by field, defaults to creation time, with newest first [Allowed "id", "created_at"]. (default created_at)
+      --wide                  Print full values in the table results
+```
+
+#### Example
+
+1. To List jobs on the network, run:
+
+```shell
+bacalhau list
+```
+2. To List jobs and output as json, run:
+
+```shell
+bacalhau list --output json
+```
+
+## Logs 
+
+The `bacalhau logs` command retrieves the log output (stdout, and stderr) from a job.
+If the job is still running it is possible to follow the logs after the previously generated logs are retrieved.
+
+Usage:
+```shell
+bacalhau logs [id] [flags]
+```
+
+```
+Flags:
+  -f, --follow   Follow the logs in real-time after retrieving the current logs.
+  -h, --help     help for logs
+```
+
+#### Examples 
+
+1. To follow logs for a previously submitted job, run:
+
+```shell
+bacalhau logs -f 51225160-807e-48b8-88c9-28311c7899e1
+```
+
+2. To retrieve the log output with a short ID, but don't follow any newly generated logs,run:
+
+```shell
+bacalhau logs ebd9bf2f
+```
+
+## Node
+
+The `bacalhau node` command provides a set of sub-commands to query and manage node-related information within Bacalhau. With these tools, users can access specific details about nodes, list all network nodes, and more.
+
+Usage:
+```shell
+bacalhau node [command]
+```
+
+Available Commands:
+
+### describe 
+
+```shell
+bacalhau node describe [id] [flags]
+```
+The `bacalhau node describe` command offers users the ability to retrieve detailed information about a specific node using its unique identifier. This information is crucial for system administrators and network managers to understand the state, specifications, and other attributes of nodes in their infrastructure.
+
+```shell
+Flags:
+  -h, --help            help for describe
+      --output format   The output format for the command (one of ["json" "yaml"]) (default yaml)
+      --pretty          Pretty print the output. Only applies to json and yaml output formats.
+```
+
+#### Examples 
+
+1. To Describe a Node with the `QmSD38wH` ID, run:
+
+```shell
+bacalhau node describe QmSD38wH
+
+Expected Output:
+BacalhauVersion:
+  BuildDate: "2023-12-11T18:46:13Z"
+  GOARCH: amd64
+  GOOS: linux
+  GitCommit: 4252ba4406c40c3d01bdcf58709f8d7a705fdc75
+  GitVersion: v1.2.0
+  Major: "1"
+  Minor: "2"
+ComputeNodeInfo:
+  AvailableCapacity:
+    CPU: 3.2
+    Disk: 1689504687718
+    GPU: 1
+    GPUs:
+    - Index: 0
+      Memory: 15360
+      Name: Tesla T4
+      PCIAddress: ""
+      Vendor: NVIDIA
+    Memory: 12561032806
+  EnqueuedExecutions: 0
+  ExecutionEngines:
+  - docker
+  - wasm
+  MaxCapacity:
+    CPU: 3.2
+    Disk: 1689504687718
+    GPU: 1
+    GPUs:
+    - Index: 0
+      Memory: 15360
+      Name: Tesla T4
+      PCIAddress: ""
+      Vendor: NVIDIA
+    Memory: 12561032806
+    ...
+```
+2. To describe a Node with Output in JSON Format, run:
+
+```shell
+bacalhau node describe QmSD38wH --output json
+
+Expected Output:
+{"PeerInfo":{"ID":"QmSD38wHdeoLrfysEejQnqpmNx4iUPh83Dh4vfYRHML9aC","Addrs":["/ip4/35.245.41.51/tcp/1235"]},"NodeType":"Compute","Labels":{"Architecture":"amd64","GPU-0":"Tesla-T4","GPU-0-Memory":"15360-MiB","Operating-System":"linux","git-lfs":"True","owner":"bacalhau"},"ComputeNodeInfo":{"ExecutionEngines":["docker","wasm"],"Publishers":["ipfs","s3","noop"],"StorageSources":["urldownload","inline","repoclone","repoclonelfs","s3","ipfs"],"MaxCapacity":{"CPU":3.2,"Memory":12561032806,"Disk":1689504687718,"GPU":1,"GPUs":[{"Index":0,"Name":"Tesla T4","Vendor":"NVIDIA","Memory":15360,"PCIAddress":""}]},"AvailableCapacity":{"CPU":3.2,"Memory":12561032806,"Disk":1689504687718,"GPU":1,"GPUs":[{"Index":0,"Name":"Tesla T4","Vendor":"NVIDIA","Memory":15360,"PCIAddress":""}]},"MaxJobRequirements":{"CPU":3.2,"Memory":12561032806,"Disk":1689504687718,"GPU":1,"GPUs":[{"Index":0,"Name":"Tesla T4","Vendor":"NVIDIA","Memory":15360,"PCIAddress":""}]},"RunningExecutions":0,"EnqueuedExecutions":0},"BacalhauVersion":{"Major":"1","Minor":"2","GitVersion":"v1.2.0","GitCommit":"4252ba4406c40c3d01bdcf58709f8d7a705fdc75","BuildDate":"2023-12-11T18:46:13Z","GOOS":"linux","GOARCH":"amd64"}}
+```
+
+### list
+
+```shell
+ bacalhau node list [flags] 
+```
+The `bacalhau node list` command is designed to provide users with a comprehensive list of network nodes along with details based on specified flags.  It supports various filtering, ordering, and output formatting options, allowing users to tailor the output to their needs.
+
+```shell
+Flags:
+  -h, --help                help for list
+      --hide-header         do not print the column headers.
+      --labels string       Filter nodes by labels. See https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ for more information.
+      --limit uint32        Limit the number of results returned
+      --next-token string   Next token to use for pagination
+      --no-style            remove all styling from table output.
+      --order-by string     Order results by a field. Valid fields are: id, type, available_cpu, available_memory, available_disk, available_gpu
+      --order-reversed      Reverse the order of the results
+      --output format       The output format for the command (one of ["table" "csv" "json" "yaml"]) (default table)
+      --pretty              Pretty print the output. Only applies to json and yaml output formats.
+      --show strings        What column groups to show. Zero or more of: ["features" "capacity" "labels" "version"] (default [labels,capacity])
+      --wide                Print full values in the table results without truncation.
+```
+
+#### Examples 
+
+1. To retrieve the list of nodes, run:
+
+```shell
+bacalhau node list
+
+Expected Output:
+ID        TYPE     LABELS                                              CPU     MEMORY      DISK         GPU
+ QmPLPUUj  Compute  Architecture=amd64 Operating-System=linux           12.8 /  50.2 GB /   1.5 TB /     0 /
+                    git-lfs=True owner=bacalhau                         12.8    50.2 GB     1.5 TB       0
+ QmRHRr8c  Compute  Architecture=amd64 GPU-0-Memory=15360-MiB           3.2 /   11.7 GB /   1.5 TB /     1 /
+                    GPU-0=Tesla-T4 Operating-System=linux git-lfs=True  3.2     11.7 GB     1.5 TB       1
+                    owner=bacalhau
+ QmSD38wH  Compute  Architecture=amd64 GPU-0-Memory=15360-MiB           3.2 /   11.7 GB /   1.5 TB /     1 /
+                    GPU-0=Tesla-T4 Operating-System=linux git-lfs=True  3.2     11.7 GB     1.5 TB       1
+                    owner=bacalhau
+  ...
+```
+
+2. To Filter the list of nodes by labels (`Operating-System` and `owner`), run:
+
+```shell
+bacalhau node list --labels "Operating-System=linux,owner=bacalhau"
+
+Expected Output:
+ ID        TYPE     LABELS                                              CPU     MEMORY      DISK         GPU
+ QmPLPUUj  Compute  Architecture=amd64 Operating-System=linux           12.8 /  50.2 GB /   1.5 TB /     0 /
+                    git-lfs=True owner=bacalhau                         12.8    50.2 GB     1.5 TB       0
+  ...
+```
+
+3. To Order the list of nodes by available memory, run:
+
+```shell
+bacalhau node list --order-by available_memory
+
+Expected Output:
+ID        TYPE       LABELS                                              CPU     MEMORY      DISK         GPU
+ QmcC3xif  Compute    Architecture=amd64 GPU-0-Memory=24576-MiB           102.0   745.1 GB /  524.0 GB /   2 /
+                      GPU-0=NVIDIA-GeForce-RTX-3090                       /       745.1 GB    524.0 GB     2
+                      GPU-1-Memory=24576-MiB                              102.0
+                      GPU-1=NVIDIA-GeForce-RTX-3090
+                      Operating-System=linux env=prod git-lfs=False
+                      name=saturnia_len20
+ QmbxGSsM  Compute    Architecture=amd64 Operating-System=linux           12.8 /  50.2 GB /   1.5 TB /     0 /
+                      git-lfs=True owner=bacalhau                         12.8    50.2 GB     1.5 TB       0
+ QmeXjeQD  Compute    Architecture=amd64 Operating-System=linux           12.8 /  50.2 GB /   1.5 TB /     0 /
+                      git-lfs=True owner=bacalhau                         12.8    50.2 GB     1.5 TB       0
+ QmPLPUUj  Compute    Architecture=amd64 Operating-System=linux           12.8 /  50.2 GB /   1.5 TB /     0 /
+                      git-lfs=True owner=bacalhau                         12.8    50.2 GB     1.5 TB       0
+ QmRHRr8c  Compute    Architecture=amd64 GPU-0-Memory=15360-MiB           3.2 /   11.7 GB /   1.5 TB /     1 /
+                      GPU-0=Tesla-T4 Operating-System=linux git-lfs=True  3.2     11.7 GB     1.5 TB       1
+                      owner=bacalhau
+ QmSD38wH  Compute    Architecture=amd64 GPU-0-Memory=15360-MiB           3.2 /   11.7 GB /   1.5 TB /     1 /
+                      GPU-0=Tesla-T4 Operating-System=linux git-lfs=True  3.2     11.7 GB     1.5 TB       1
+                      owner=bacalhau
+ QmWsayXK  Requester  Architecture=arm64 Operating-System=linux
+                      git-lfs=False
+```
+
+4.  To get a limited list of nodes (3) in JSON format, run:
+
+```shell
+bacalhau node list  --limit 3 --output json --pretty
+
+Expected Output:
+[
+  {
+    "PeerInfo": {
+      "ID": "QmPLPUUjaVE3wQNSSkxmYoaBPHVAWdjBjDYmMkWvtMZxAf",
+      "Addrs": [
+        "/ip4/35.245.215.155/tcp/1235"
+      ]
+    },
+    "NodeType": "Compute",
+    "Labels": {
+      "Architecture": "amd64",
+      "Operating-System": "linux",
+      "git-lfs": "True",
+      "owner": "bacalhau"
+    },
+   ... 
+```
+
+## Serve
+
+The `bacalhau serve` command starts a bacalhau node.
+
+Usage:
+```shell
+bacalhau serve [flags]
+```
+
+```shell
+Flags:
+      --allow-listed-local-paths strings                 Local paths that are allowed to be mounted into jobs
+      --autocert string                                  Specifies a host name for which ACME is used to obtain a TLS Certificate.
+                                                         Using this option results in the API serving over HTTPS
+      --compute-execution-store-path string              The path used for the compute execution store when using BoltDB
+      --compute-execution-store-type storage-type        The type of store used by the compute node (BoltDB or InMemory) (default BoltDB)
+      --default-job-execution-timeout duration           default value for the execution timeout this compute node will assign to jobs with no timeout requirement defined. (default 10m0s)
+      --disable-engine strings                           Engine types to disable
+      --disable-storage strings                          Storage types to disable
+      --disabled-publisher strings                       Publisher types to disable
+  -h, --help                                             help for serve
+      --host string                                      The host to serve on. (default "0.0.0.0")
+      --ignore-physical-resource-limits                  When set the compute node will ignore is physical resource limits
+      --ipfs-connect string                              The ipfs host multiaddress to connect to, otherwise an in-process IPFS node will be created if not set.
+      --ipfs-serve-path string                           path local Ipfs node will persist data to
+      --ipfs-swarm-addrs strings                         IPFS multiaddress to connect the in-process IPFS node to - cannot be used with --ipfs-connect. (default [/ip4/35.245.161.250/tcp/4001/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/35.245.161.250/udp/4001/quic/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/34.86.254.26/tcp/4001/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/34.86.254.26/udp/4001/quic/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/35.245.215.155/tcp/4001/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/35.245.215.155/udp/4001/quic/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/34.145.201.224/tcp/4001/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/34.145.201.224/udp/4001/quic/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/35.245.41.51/tcp/4001/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa,/ip4/35.245.41.51/udp/4001/quic/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa])
+      --ipfs-swarm-key string                            Optional IPFS swarm key required to connect to a private IPFS swarm
+      --job-execution-timeout-bypass-client-id strings   List of IDs of clients that are allowed to bypass the job execution timeout check
+      --job-negotiation-timeout duration                 Timeout value to hold a bid for a job. (default 3m0s)
+      --job-selection-accept-networked                   Accept jobs that require network access.
+      --job-selection-data-locality local|anywhere       Only accept jobs that reference data we have locally ("local") or anywhere ("anywhere"). (default Anywhere)
+      --job-selection-probe-exec string                  Use the result of a exec an external program to decide if we should take on the job.
+      --job-selection-probe-http string                  Use the result of a HTTP POST to decide if we should take on the job.
+      --job-selection-reject-stateless                   Reject jobs that don't specify any data.
+      --labels stringToString                            Labels to be associated with the node that can be used for node selection and filtering. (e.g. --labels key1=value1,key2=value2) (default [])
+      --limit-job-cpu string                             Job CPU core limit to run all jobs (e.g. 500m, 2, 8).
+      --limit-job-gpu string                             Job GPU limit to run all jobs (e.g. 1, 2, or 8).
+      --limit-job-memory string                          Job Memory limit to run all jobs  (e.g. 500Mb, 2Gb, 8Gb).
+      --limit-total-cpu string                           Total CPU core limit to run all jobs (e.g. 500m, 2, 8).
+      --limit-total-gpu string                           Total GPU limit to run all jobs (e.g. 1, 2, or 8).
+      --limit-total-memory string                        Total Memory limit to run all jobs  (e.g. 500Mb, 2Gb, 8Gb).
+      --max-job-execution-timeout duration               The maximum execution timeout this compute node supports. Jobs with higher timeout requirements will not be bid on. (default 2562047h47m16s)
+      --min-job-execution-timeout duration               The minimum execution timeout this compute node supports. Jobs with lower timeout requirements will not be bid on. (default 500ms)
+      --node-type strings                                Whether the node is a compute, requester or both. (default [requester])
+      --peer string                                      A comma-separated list of libp2p multiaddress to connect to. Use "none" to avoid connecting to any peer, "env" to connect to the default peer list of your active environment (see BACALHAU_ENVIRONMENT env var). (default "none")
+      --port int                                         The port to server on. (default 1234)
+      --private-internal-ipfs                            Whether the in-process IPFS node should auto-discover other nodes, including the public IPFS network - cannot be used with --ipfs-connect. Use "--private-internal-ipfs=false" to disable. To persist a local Ipfs node, set BACALHAU_SERVE_IPFS_PATH to a valid path. (default true)
+      --requester-job-store-path string                  The path used for the requester job store store when using BoltDB
+      --requester-job-store-type storage-type            The type of job store used by the requester node (BoltDB or InMemory) (default BoltDB)
+      --swarm-port int                                   The port to listen on for swarm connections. (default 1235)
+      --tlscert string                                   Specifies a TLS certificate file to be used by the requester node
+      --tlskey string                                    Specifies a TLS key file matching the certificate to be used by the requester node
+      --web-ui                                           Whether to start the web UI alongside the bacalhau node.
+```
+
+#### Examples 
+
+1. To Start a private bacalhau requester node, you can run either of these two commands:
+
+```shell
+bacalhau serve
+
+or
+
+bacalhau serve --node-type requester
+```
+
+2. To Start a private bacalhau hybrid node that acts as both compute and requester, you can run either of these two commands:
+
+```shell
+bacalhau serve --node-type compute --node-type requester
+
+or
+
+bacalhau serve --node-type compute,requester
+```
+
+3. To Start a private bacalhau node with a persistent local IPFS node, run:
+
+```shell
+BACALHAU_SERVE_IPFS_PATH=/data/ipfs bacalhau serve
+```
+The command creates and starts a Bacalhau private node using the local IPFS node and specifies the path to save the IPFS data.
+
+4. To Start a public bacalhau requester node, run:
+
+```shell
+bacalhau serve --peer env --private-internal-ipfs=false
+```
+
+5. To Start a public bacalhau node with the WebUI, run:
+
+```shell
+bacalhau serve --webui
+```
+
+## Validate
+
+The `bacalhau validate` command allows you to validate job files in JSON or YAML formats before sending them to the Bacalhau system. It is used to confirm that the structure and contents of the job description file conform to the expected format.
+
+Usage:
+```shell
+bacalhau validate [flags]
+```
+
+```shell
+Flags:
+  -h, --help            help for validate
+      --output-schema   Output the JSON schema for a Job to stdout then exit
+```
+
+#### Example 
+
+To Validate the `job.yaml` file, run:
+
+```shell
+bacalhau validate ./job.yaml
+```
+
+## Version
+
+The `bacalhau version` command allows you to get the client and server version.
+
+Usage:
+```shell
+bacalhau version [flags]
+```
+
+```shell
+Flags:
+      --client          If true, shows client version only (no server required).
+  -h, --help            help for version
+      --hide-header     do not print the column headers.
+      --no-style        remove all styling from table output.
+      --output format   The output format for the command (one of ["table" "csv" "json" "yaml"]) (default table)
+      --pretty          Pretty print the output. Only applies to json and yaml output formats.
+      --wide            Print full values in the table results
+```
+
+## Wasm
+
+The `bacalhau wasm` command Runs and prepares WASM jobs on the network
+
+Usage:
+```shell
+bacalhau wasm [command]
+```
+
+Available Commands:
+
+### run
+
+```shell
+bacalhau wasm run {cid-of-wasm | <local.wasm>} [--entry-point <string>] [wasm-args ...] [flags]
+```
+The `bacalhau wasm run` command Runs a job that was compiled to WASM.
+
+```shell
+Flags:
+      --concurrency int                  How many nodes should run the job (default 1)
+      --cpu string                       Job CPU cores (e.g. 500m, 2, 8).
+      --disk string                      Job Disk requirement (e.g. 500Gb, 2Tb, 8Tb).
+      --do-not-track                     When true the job will not be tracked(?) TODO BETTER DEFINITION
+      --domain stringArray               Domain(s) that the job needs to access (for HTTP networking)
+      --download                         Should we download the results once the job is complete?
+      --download-timeout-secs duration   Timeout duration for IPFS downloads. (default 5m0s)
+      --dry-run                          Do not submit the job, but instead print out what will be submitted
+      --entry-point string               The name of the WASM function in the entry module to call. This should be a zero-parameter zero-result function that
+                                         		will execute the job. (default "_start")
+  -e, --env strings                      The environment variables to supply to the job (e.g. --env FOO=bar --env BAR=baz)
+  -f, --follow                           When specified will follow the output from the job as it runs
+  -g, --gettimeout int                   Timeout for getting the results of a job in --wait (default 10)
+      --gpu string                       Job GPU requirement (e.g. 1, 2, 8).
+  -h, --help                             help for run
+      --id-only                          Print out only the Job ID on successful submission.
+  -U, --import-module-urls url           URL of the WASM modules to import from a URL source. URL accept any valid URL supported by the 'wget' command, and supports both HTTP and HTTPS.
+  -I, --import-module-volumes cid:path   CID:path of the WASM modules to import from IPFS, if you need to set the path of the mounted data.
+  -i, --input storage                    Mount URIs as inputs to the job. Can be specified multiple times. Format: src=URI,dst=PATH[,opt=key=value]
+                                         Examples:
+                                         # Mount IPFS CID to /inputs directory
+                                         -i ipfs://QmeZRGhe4PmjctYVSVHuEiA9oSXnqmYa4kQubSHgWbjv72
+                                         # Mount S3 object to a specific path
+                                         -i s3://bucket/key,dst=/my/input/path
+                                         # Mount S3 object with specific endpoint and region
+                                         -i src=s3://bucket/key,dst=/my/input/path,opt=endpoint=https://s3.example.com,opt=region=us-east-1
+      --ipfs-connect string              The ipfs host multiaddress to connect to, otherwise an in-process IPFS node will be created if not set.
+      --ipfs-serve-path string           path local Ipfs node will persist data to
+      --ipfs-swarm-addrs strings         IPFS multiaddress to connect the in-process IPFS node to - cannot be used with --ipfs-connect. (default [/ip4/35.245.161.250/tcp/4001/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/35.245.161.250/udp/4001/quic/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/34.86.254.26/tcp/4001/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/34.86.254.26/udp/4001/quic/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/35.245.215.155/tcp/4001/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/35.245.215.155/udp/4001/quic/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/34.145.201.224/tcp/4001/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/34.145.201.224/udp/4001/quic/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/35.245.41.51/tcp/4001/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa,/ip4/35.245.41.51/udp/4001/quic/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa])
+      --ipfs-swarm-key string            Optional IPFS swarm key required to connect to a private IPFS swarm
+  -l, --labels strings                   List of labels for the job. Enter multiple in the format '-l a -l 2'. All characters not matching /a-zA-Z0-9_:|-/ and all emojis will be stripped.
+      --memory string                    Job Memory requirement (e.g. 500Mb, 2Gb, 8Gb).
+      --network network-type             Networking capability required by the job. None, HTTP, or Full (default None)
+      --node-details                     Print out details of all nodes (overridden by --id-only).
+  -o, --output strings                   name:path of the output data volumes. 'outputs:/outputs' is always added unless '/outputs' is mapped to a different name. (default [outputs:/outputs])
+      --output-dir string                Directory to write the output to.
+      --private-internal-ipfs            Whether the in-process IPFS node should auto-discover other nodes, including the public IPFS network - cannot be used with --ipfs-connect. Use "--private-internal-ipfs=false" to disable. To persist a local Ipfs node, set BACALHAU_SERVE_IPFS_PATH to a valid path. (default true)
+  -p, --publisher publisher              Where to publish the result of the job (default ipfs)
+      --raw                              Download raw result CIDs instead of merging multiple CIDs into a single result
+  -s, --selector string                  Selector (label query) to filter nodes on which this job can be executed, supports '=', '==', and '!='.(e.g. -s key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints.
+      --target all|any                   Whether to target the minimum number of matching nodes ("any") (default) or all matching nodes ("all") (default any)
+      --timeout int                      Job execution timeout in seconds (e.g. 300 for 5 minutes)
+      --wait                             Wait for the job to finish. Use --wait=false to return as soon as the job is submitted. (default true)
+      --wait-timeout-secs int            When using --wait, how many seconds to wait for the job to complete before giving up. (default 600)
+```
+
+#### Examples
+
+1. To Run the `<localfile.wasm>` module in bacalhau:
+
+```shell
+bacalhau wasm run <localfile.wasm>
+```
+
+2. To Fetch the wasm module from `<cid>` and execute it, run:
+
+```shell
+bacalhau wasm run <cid>
+```
+
+### validate 
+
+```shell
+bacalhau wasm validate <local.wasm> [--entry-point <string>] [flags]
+```
+
+The `bacalhau wasm validate` command Checks that a WASM program is runnable on the network.
+
+```shell
+Flags:
+      --entry-point string   The name of the WASM function in the entry module to call. This should be a zero-parameter zero-result function that will execute the job. (default "_start")
+  -h, --help                 help for validate
+```
\ No newline at end of file
diff --git a/docs/docs/dev/cli-reference/cli/_category_.yml b/docs/docs/dev/cli-reference/cli/_category_.yml
new file mode 100644
index 0000000000..601000263c
--- /dev/null
+++ b/docs/docs/dev/cli-reference/cli/_category_.yml
@@ -0,0 +1,1 @@
+label: "Advanced Commands"
\ No newline at end of file
diff --git a/docs/docs/references/cli/agent/_category_.yml b/docs/docs/dev/cli-reference/cli/agent/_category_.yml
similarity index 100%
rename from docs/docs/references/cli/agent/_category_.yml
rename to docs/docs/dev/cli-reference/cli/agent/_category_.yml
diff --git a/docs/docs/references/cli/agent/alive/index.md b/docs/docs/dev/cli-reference/cli/agent/alive/index.md
similarity index 100%
rename from docs/docs/references/cli/agent/alive/index.md
rename to docs/docs/dev/cli-reference/cli/agent/alive/index.md
diff --git a/docs/docs/references/cli/agent/index.md b/docs/docs/dev/cli-reference/cli/agent/index.md
similarity index 100%
rename from docs/docs/references/cli/agent/index.md
rename to docs/docs/dev/cli-reference/cli/agent/index.md
diff --git a/docs/docs/references/cli/agent/node/index.md b/docs/docs/dev/cli-reference/cli/agent/node/index.md
similarity index 100%
rename from docs/docs/references/cli/agent/node/index.md
rename to docs/docs/dev/cli-reference/cli/agent/node/index.md
diff --git a/docs/docs/references/cli/agent/version/index.md b/docs/docs/dev/cli-reference/cli/agent/version/index.md
similarity index 100%
rename from docs/docs/references/cli/agent/version/index.md
rename to docs/docs/dev/cli-reference/cli/agent/version/index.md
diff --git a/docs/docs/references/cli/config/_category_.yml b/docs/docs/dev/cli-reference/cli/config/_category_.yml
similarity index 100%
rename from docs/docs/references/cli/config/_category_.yml
rename to docs/docs/dev/cli-reference/cli/config/_category_.yml
diff --git a/docs/docs/references/cli/config/auto-resources.md b/docs/docs/dev/cli-reference/cli/config/auto-resources.md
similarity index 100%
rename from docs/docs/references/cli/config/auto-resources.md
rename to docs/docs/dev/cli-reference/cli/config/auto-resources.md
diff --git a/docs/docs/references/cli/config/default.md b/docs/docs/dev/cli-reference/cli/config/default.md
similarity index 100%
rename from docs/docs/references/cli/config/default.md
rename to docs/docs/dev/cli-reference/cli/config/default.md
diff --git a/docs/docs/references/cli/config/index.md b/docs/docs/dev/cli-reference/cli/config/index.md
similarity index 100%
rename from docs/docs/references/cli/config/index.md
rename to docs/docs/dev/cli-reference/cli/config/index.md
diff --git a/docs/docs/references/cli/config/list.md b/docs/docs/dev/cli-reference/cli/config/list.md
similarity index 100%
rename from docs/docs/references/cli/config/list.md
rename to docs/docs/dev/cli-reference/cli/config/list.md
diff --git a/docs/docs/references/cli/config/set.md b/docs/docs/dev/cli-reference/cli/config/set.md
similarity index 100%
rename from docs/docs/references/cli/config/set.md
rename to docs/docs/dev/cli-reference/cli/config/set.md
diff --git a/docs/docs/references/cli/index.md b/docs/docs/dev/cli-reference/cli/index.md
similarity index 100%
rename from docs/docs/references/cli/index.md
rename to docs/docs/dev/cli-reference/cli/index.md
diff --git a/docs/docs/references/cli/job/_category_.yml b/docs/docs/dev/cli-reference/cli/job/_category_.yml
similarity index 100%
rename from docs/docs/references/cli/job/_category_.yml
rename to docs/docs/dev/cli-reference/cli/job/_category_.yml
diff --git a/docs/docs/references/cli/job/describe/index.md b/docs/docs/dev/cli-reference/cli/job/describe/index.md
similarity index 100%
rename from docs/docs/references/cli/job/describe/index.md
rename to docs/docs/dev/cli-reference/cli/job/describe/index.md
diff --git a/docs/docs/references/cli/job/executions/index.md b/docs/docs/dev/cli-reference/cli/job/executions/index.md
similarity index 100%
rename from docs/docs/references/cli/job/executions/index.md
rename to docs/docs/dev/cli-reference/cli/job/executions/index.md
diff --git a/docs/docs/references/cli/job/history/index.md b/docs/docs/dev/cli-reference/cli/job/history/index.md
similarity index 100%
rename from docs/docs/references/cli/job/history/index.md
rename to docs/docs/dev/cli-reference/cli/job/history/index.md
diff --git a/docs/docs/references/cli/job/index.md b/docs/docs/dev/cli-reference/cli/job/index.md
similarity index 100%
rename from docs/docs/references/cli/job/index.md
rename to docs/docs/dev/cli-reference/cli/job/index.md
diff --git a/docs/docs/references/cli/job/list/index.md b/docs/docs/dev/cli-reference/cli/job/list/index.md
similarity index 100%
rename from docs/docs/references/cli/job/list/index.md
rename to docs/docs/dev/cli-reference/cli/job/list/index.md
diff --git a/docs/docs/references/cli/job/logs/index.md b/docs/docs/dev/cli-reference/cli/job/logs/index.md
similarity index 100%
rename from docs/docs/references/cli/job/logs/index.md
rename to docs/docs/dev/cli-reference/cli/job/logs/index.md
diff --git a/docs/docs/references/cli/job/run/index.md b/docs/docs/dev/cli-reference/cli/job/run/index.md
similarity index 98%
rename from docs/docs/references/cli/job/run/index.md
rename to docs/docs/dev/cli-reference/cli/job/run/index.md
index df941f5db8..2f2c12d92d 100644
--- a/docs/docs/references/cli/job/run/index.md
+++ b/docs/docs/dev/cli-reference/cli/job/run/index.md
@@ -236,4 +236,5 @@ This configuration describes a batch job that runs a Docker task. It utilizes th
    ```
 
 ## Templating
-`bacalhau job run` providing users with the ability to dynamically inject variables into their job specifications. This feature is particularly useful when running multiple jobs with varying parameters such as S3 buckets, prefixes, and time ranges without the need to edit each job specification file manually. You can find more information about templating [here](/topic-guides/job-templating.md).
\ No newline at end of file
+`bacalhau job run` providing users with the ability to dynamically inject variables into their job specifications. This feature is particularly useful when running multiple jobs with varying parameters such as S3 buckets, prefixes, and time ranges without the need to edit each job specification file manually. You can find more information about templating [here](/setting-up/jobs/job-templating.md).
+
diff --git a/docs/docs/references/cli/job/stop/index.md b/docs/docs/dev/cli-reference/cli/job/stop/index.md
similarity index 100%
rename from docs/docs/references/cli/job/stop/index.md
rename to docs/docs/dev/cli-reference/cli/job/stop/index.md
diff --git a/docs/docs/references/cli/node/_category_.yml b/docs/docs/dev/cli-reference/cli/node/_category_.yml
similarity index 100%
rename from docs/docs/references/cli/node/_category_.yml
rename to docs/docs/dev/cli-reference/cli/node/_category_.yml
diff --git a/docs/docs/references/cli/node/describe/index.md b/docs/docs/dev/cli-reference/cli/node/describe/index.md
similarity index 100%
rename from docs/docs/references/cli/node/describe/index.md
rename to docs/docs/dev/cli-reference/cli/node/describe/index.md
diff --git a/docs/docs/references/cli/node/index.md b/docs/docs/dev/cli-reference/cli/node/index.md
similarity index 100%
rename from docs/docs/references/cli/node/index.md
rename to docs/docs/dev/cli-reference/cli/node/index.md
diff --git a/docs/docs/references/cli/node/list/index.md b/docs/docs/dev/cli-reference/cli/node/list/index.md
similarity index 100%
rename from docs/docs/references/cli/node/list/index.md
rename to docs/docs/dev/cli-reference/cli/node/list/index.md
diff --git a/docs/docs/dev/databases.md b/docs/docs/dev/databases.md
index e102b0f37d..3a8f230e25 100644
--- a/docs/docs/dev/databases.md
+++ b/docs/docs/dev/databases.md
@@ -1,4 +1,4 @@
-# Databases
+# Database Integration
 
 ## Requester node database (job store)
 
diff --git a/docs/docs/dev/debugging/_category_.yml b/docs/docs/dev/debugging/_category_.yml
new file mode 100644
index 0000000000..63851f2a58
--- /dev/null
+++ b/docs/docs/dev/debugging/_category_.yml
@@ -0,0 +1,2 @@
+label: "Debugging"
+position: 3
diff --git a/docs/docs/troubleshooting/debugging.md b/docs/docs/dev/debugging/debugging-general.md
similarity index 96%
rename from docs/docs/troubleshooting/debugging.md
rename to docs/docs/dev/debugging/debugging-general.md
index c94dca4383..ca8dfe1f71 100644
--- a/docs/docs/troubleshooting/debugging.md
+++ b/docs/docs/dev/debugging/debugging-general.md
@@ -1,10 +1,10 @@
 ---
-sidebar_label: 'Debugging Jobs'
+sidebar_label: 'Debugging Fundamentals'
 sidebar_position: 1
 description: 'How to troubleshoot and debug failed Bacalhau jobs'
 ---
 
-# Debugging Failed Jobs
+# Fundamentals - Debugging Failed Jobs
 
 > "An expert is a person who has made all the mistakes that can be made in a very narrow field." ― Niels Bohr
 
@@ -145,7 +145,7 @@ Before running a Bacalhau job for real, it's worth taking the time to slowly bab
 * Finally, try and run the actual job.
 * If the job fails, try to tailor a job that tests the specific issue you're facing.
 
-In essence, you should try and derisk the job by intentionally testing all the normal things that can go wrong, like data not being in the right place or in the wrong format.
+In essence, you should try and minimize failure of the job by intentionally testing all the normal things that can go wrong, like data not being in the right place or in the wrong format.
 
 ## Support
 
diff --git a/docs/docs/dev/debugging_locally.md b/docs/docs/dev/debugging/debugging_locally.md
similarity index 100%
rename from docs/docs/dev/debugging_locally.md
rename to docs/docs/dev/debugging/debugging_locally.md
diff --git a/docs/docs/examples/data-engineering/oceanography-conversion/index.md b/docs/docs/examples/data-engineering/oceanography-conversion/index.md
index cb52bf1477..cd33fc7503 100644
--- a/docs/docs/examples/data-engineering/oceanography-conversion/index.md
+++ b/docs/docs/examples/data-engineering/oceanography-conversion/index.md
@@ -234,7 +234,7 @@ docker push <hub-user>/<repo-name>:<tag>
 ```
 
 :::tip
-For more information about working with custom containers, see the [custom containers example](../../workload-onboarding/custom-containers/).
+For more information about working with custom containers, see the [custom containers example](../../../setting-up/workload-onboarding/custom-containers/).
 :::
 
 ## Running a Bacalhau Job
diff --git a/docs/docs/examples/index.md b/docs/docs/examples/index.md
index fcb3801c91..90188f8fdf 100644
--- a/docs/docs/examples/index.md
+++ b/docs/docs/examples/index.md
@@ -25,7 +25,7 @@ We're adding examples all the time. Check back soon for more!
 ## Usage
 
 Each example walks you through a specific task and aims at being as self-contained as possible.
-For starters, we recommended starting from examples whose prerequisites include only the Bacalhau client (e.g. [Python Hello World](./workload-onboarding/Prolog-Hello-World/index.md)).
+For starters, we recommended starting from examples whose prerequisites include only the Bacalhau client (e.g. [Python Hello World](../setting-up/workload-onboarding/Prolog-Hello-World/index.md)).
 First read through an example to grasp its objectives and syntax, once you feel confident with those you may want to run it *interactively*.
 
 ### Structure
diff --git a/docs/docs/examples/workload-onboarding/CUDA/index.md b/docs/docs/examples/workload-onboarding/CUDA/index.md
deleted file mode 100644
index 2add39104e..0000000000
--- a/docs/docs/examples/workload-onboarding/CUDA/index.md
+++ /dev/null
@@ -1,165 +0,0 @@
----
-sidebar_label: "CUDA"
-sidebar_position: 10
----
-# Run CUDA programs on Bacalhau
-
-
-[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
-
-### What is CUDA
-
-In this tutorial, we will look at how to run CUDA programs on Bacalhau. CUDA (Compute Unified Device Architecture) is an extension of C/C++ programming. It is a parallel computing platform and programming model created by NVIDIA. It helps developers speed up their applications by harnessing the power of GPU accelerators.
-
-In addition to accelerating high-performance computing (HPC) and research applications, CUDA has also been widely adopted across consumer and industrial ecosystems. CUDA also makes it easy for developers to take advantage of all the latest GPU architecture innovations
-
-### Advantage of GPU over CPU
-Architecturally, the CPU is composed of just a few cores with lots of cache memory that can handle a few software threads at a time. In contrast, a GPU is composed of hundreds of cores that can handle thousands of threads simultaneously.
-
-Computations like matrix multiplication could be done much faster on GPU than on CPU
-
-## TD;LR
-Running CUDA programs on Bacalhau
-
-## Prerequisite
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-## Running CUDA locally
-
-You'll need to have the following installed:
-- NVIDIA GPU
-- CUDA drivers installed
-- nvcc installed
-
-Checking if nvcc is installed
-
-
-```python
-!nvcc --version
-```
-
-Downloading the programs
-
-
-```bash
-%%bash
-mkdir inputs outputs
-wget -P inputs https://raw.githubusercontent.com/tristanpenman/cuda-examples/master/00-hello-world.cu
-wget -P inputs https://raw.githubusercontent.com/tristanpenman/cuda-examples/master/02-cuda-hello-world-faster.cu
-```
-
-### Viewing the programs
-
-
-```bash
-%%bash
-cat inputs/00-hello-world.cu
-```
-
-This is a standard C++ program, which uses loops that are not parallelizable so it doesn't use the most processing power of the GPU
-
-
-```python
-%%timeit
-!nvcc -o ./outputs/hello ./inputs/00-hello-world.cu; ./outputs/hello
-```
-
-
-```python
-!cat inputs/02-cuda-hello-world-faster.cu
-```
-
-Instead of looping we use Vector addition using CUDA and allocate the memory in advance and copy the memory to the GPU
-using cudaMemcpy so that it can utilize the HBM (High Bandwidth memory of the GPU)
-
-
-```python
-!rm -rf outputs/hello
-```
-
-
-```python
-%%timeit
-!nvcc --expt-relaxed-constexpr  -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu; ./outputs/hello
-```
-
-It takes around 8.67s to run
-00-hello-world.cu
-while it takes 1.39s to run
-02-cuda-hello-world-faster.cu
-
-
-## Running a Bacalhau Job
-
-To submit a job, run the following Bacalhau command:
-
-
-```bash
-%%bash --out job_id
- bacalhau docker run \
---gpu 1 \
---timeout 3600 \
---wait-timeout-secs 3600 \
- -i https://raw.githubusercontent.com/tristanpenman/cuda-examples/master/02-cuda-hello-world-faster.cu \
- --id-only \
- --wait \
- nvidia/cuda:11.2.0-cudnn8-devel-ubuntu18.04 \
--- /bin/bash -c 'nvcc --expt-relaxed-constexpr  -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu; ./outputs/hello '
-```
-
-## Structure of Bacalhau Commands
-
-Let's look closely at the command above:
-
-* `-i < Link-To-The-Program >`: The program is mounted by using the `-i` flag you can specify the link there
-
-* `nvidia/cuda:11.2.0-cudnn8-devel-ubuntu18.04`: Docker container for executing CUDA programs you need to choose the right CUDA docker container the container should have the tag of devel in them
-
-* `nvcc --expt-relaxed-constexpr  -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu`: Compilation using the nvcc compiler and save it to the outputs directory as hello
-
-* `./outputs/hello`: Execution hello binary:
-* You can combine compilation and execution commands. Note that there is `;` between the commands:
-  `-- /bin/bash -c 'nvcc --expt-relaxed-constexpr  -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu; ./outputs/hello `
-
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
-
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
-
-
-```bash
-%%bash
-bacalhau list --id-filter ${JOB_ID} --wide
-```
-
-When it says `Published` or `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
-
-
-
-```bash
-%%bash
-bacalhau describe ${JOB_ID}
-```
-
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
-
-
-```bash
-%%bash
-rm -rf results && mkdir -p results
-bacalhau get $JOB_ID --output-dir results
-```
-
-## Viewing your Job Output
-
-To view the file, run the following command:
-
-
-```bash
-%%bash
-cat results/stdout # displays the contents of the file
-```
diff --git a/docs/docs/examples/workload-onboarding/Running-Jupyter-Notebook/index.md b/docs/docs/examples/workload-onboarding/Running-Jupyter-Notebook/index.md
deleted file mode 100644
index 67f76f8201..0000000000
--- a/docs/docs/examples/workload-onboarding/Running-Jupyter-Notebook/index.md
+++ /dev/null
@@ -1,209 +0,0 @@
----
-sidebar_label: "Running-Jupyter-Notebook"
-sidebar_position: 3
----
-# Running Jupyter Notebooks on bacalhau
-
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/bacalhau-project/examples/blob/main/workload-onboarding/Running-Jupyter-Notebook/index.ipynb)
-[![Open In Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/bacalhau-project/examples/HEAD?labpath=workload-onboarding/Running-Jupyter-Notebook/index.ipynb)
-[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
-
-## Introduction
-Jupyter Notebooks have become an essential tool for data scientists, researchers, and developers for interactive computing and the development of data-driven projects. They provide an efficient way to share code, equations, visualizations, and narrative text with support for multiple programming languages. In this tutorial, we will introduce you to running Jupyter Notebooks on Bacalhau, a powerful and flexible container orchestration platform. By leveraging Bacalhau, you can execute Jupyter Notebooks in a scalable and efficient manner using Docker containers, without the need for manual setup or configuration.
-
-In the following sections, we will explore two examples of executing Jupyter Notebooks on Bacalhau:
-
-1. Executing a Simple Hello World Notebook: We will begin with a basic example to familiarize you with the process of running a Jupyter Notebook on Bacalhau. We will execute a simple "Hello, World!" notebook to demonstrate the steps required for running a notebook in a containerized environment.
-
-2. Notebook to Train an MNIST Model: In this section, we will dive into a more advanced example. We will execute a Jupyter Notebook that trains a machine-learning model on the popular MNIST dataset. This will showcase the potential of Bacalhau to handle more complex tasks while providing you with insights into utilizing containerized environments for your data science projects.
-
-## 1. Executing a Simple Hello World Notebook
-
-There are no external dependencies that we need to install all dependencies are already there in the container
-
-### Prerequisite
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-
-```bash
-%%bash --out job_id
-bacalhau docker run \
---wait \
---id-only \
---timeout 3600 \
---wait-timeout-secs 3600 \
--w /inputs \
--i https://raw.githubusercontent.com/js-ts/hello-notebook/main/hello.ipynb \
-jsacex/jupyter \
--- jupyter nbconvert --execute --to notebook --output /outputs/hello_output.ipynb hello.ipynb
-```
-
-- `-i`: This flag stands for "input" and is used to provide the URL of the input Jupyter Notebook you want to execute. In this case, we are using a public gist containing the 'hello.ipynb' notebook.
-- `https://gist.githubusercontent.com/js-ts/54d1015af4cb2ec5882ada2180ec042c/raw/a4c07357db014572da2ff27628a3669bfb99ba4d/hello.ipynb`: This is the URL of the input Jupyter Notebook.
-- `jupyter/base-notebook`: This is the name of the Docker image used for running the Jupyter Notebook. It is a minimal Jupyter Notebook stack based on the official Jupyter Docker Stacks.
-- `--`: This double dash is used to separate the Bacalhau command options from the command that will be executed inside the Docker container.
-- `jupyter nbconvert`: This is the primary command used to convert and execute Jupyter Notebooks. It allows for the conversion of notebooks to various formats, including execution.
-- `--execute`: This flag tells `nbconvert` to execute the notebook and store the results in the output file.
-- `--to notebook`: This option specifies the output format. In this case, we want to keep the output as a Jupyter Notebook.
-- `--output /outputs/hello_output.ipynb`: This option specifies the path and filename for the output Jupyter Notebook, which will contain the results of the executed input notebook.
-- `/inputs/hello.ipynb`: This is the path of the input Jupyter Notebook inside the Docker container.
-
-
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
-
-
-```bash
-%%bash
-bacalhau list --id-filter=${JOB_ID} --no-style
-```
-
-When it says `Published` or `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
-
-
-```bash
-%%bash
-bacalhau describe ${JOB_ID}
-```
-
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
-
-
-```bash
-%%bash
-rm -rf results && mkdir results # Temporary directory to store the results
-bacalhau get ${JOB_ID} --output-dir results # Download the results
-```
-
-After the download has finished you should see the following contents in the results directory.
-
-
-```bash
-%%bash
-ls results/outputs
-```
-
-## 2. Running Notebook to Train an MNIST Model
-
-### Building the container (optional)
-
-#### Prerequisite
-- Install Docker on your local machine.
-- Sign up for a DockerHub account if you don't already have one.
-  Steps
-
-Step 1: Create a Dockerfile
-Create a new file named Dockerfile in your project directory with the following content:
-
-```Dockerfile
-# Use the official Python image as the base image
-FROM tensorflow/tensorflow:nightly-gpu
-
-# Set the working directory in the container
-WORKDIR /
-
-RUN apt-get update -y
-
-COPY mnist.ipynb .
-# Install the Python packages
-COPY requirements.txt .
-
-RUN python3 -m pip install --upgrade pip
-
-# Install the Python packages
-RUN pip install --no-cache-dir -r requirements.txt
-
-RUN pip install -U scikit-learn
-```
-This Dockerfile creates a Docker image based on the official TensorFlow GPU-enabled image, sets the working directory to the root, updates the package list, and copies an IPython notebook (mnist.ipynb) and a requirements.txt file. It then upgrades pip and installs Python packages from the requirements.txt file, along with scikit-learn. The resulting image provides an environment ready for running the mnist.ipynb notebook with TensorFlow and scikit-learn, as well as other specified dependencies.
-
-Step 2: Build the Docker Image
-In your terminal, navigate to the directory containing the Dockerfile and run the following command to build the Docker image:
-
-```bash
-docker build -t your-dockerhub-username/jupyter-mnist-tensorflow:latest .
-```
-Replace "your-dockerhub-username" with your actual DockerHub username. This command will build the Docker image and tag it with your DockerHub username and the name "your-dockerhub-username/jupyter-mnist-tensorflow".
-
-Step 3: Push the Docker Image to DockerHub
-Once the build process is complete, Next, push the Docker image to DockerHub using the following command:
-```bash
-docker push your-dockerhub-username/jupyter-mnist-tensorflow
-```
-
-Again, replace "your-dockerhub-username" with your actual DockerHub username. This command will push the Docker image to your DockerHub repository.
-
-### Running the job on Bacalhau
-
-#### Prerequisite
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-
-```bash
-%%bash --out job_id
-bacalhau docker run \
---wait \
---id-only \
---timeout 3600 \
---wait-timeout-secs 3600 \
- --gpu 1 \
--i gitlfs://huggingface.co/datasets/VedantPadwal/mnist.git \
-jsacex/jupyter-tensorflow-mnist:v02 \
--- jupyter nbconvert --execute --to notebook --output /outputs/mnist_output.ipynb mnist.ipynb
-```
-
-### Structure of the command
-
-* `--gpu 1`: Flag to specify the number of GPUs to use for the execution. In this case, 1 GPU will be used.
-
-* `-i gitlfs://huggingface.co/datasets/VedantPadwal/mnist.git`: The `-i` flag is used to clone the MNIST dataset from Hugging Face's repository using Git LFS. The files will be mounted inside the container.
-
-* `jsacex/jupyter-tensorflow-mnist:v02`: The name and the tag of the Docker image.
-
-* `--`: Double hyphen is used to separate the Docker command-line options from the command that will be executed inside the container.
-
-* `jupyter nbconvert --execute --to notebook --output /outputs/mnist_output.ipynb mnist.ipynb`: The command to be executed inside the container. In this case, it runs the `jupyter nbconvert` command to execute the `mnist.ipynb` notebook and save the output as `mnist_output.ipynb` in the `/outputs` directory.
-
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
-
-
-```bash
-%%bash
-bacalhau list --id-filter=${JOB_ID} --no-style
-```
-
-When it says `Published` or `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
-
-
-```bash
-%%bash
-bacalhau describe ${JOB_ID}
-```
-
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
-
-
-```bash
-%%bash
-rm -rf results && mkdir results # Temporary directory to store the results
-bacalhau get ${JOB_ID} --output-dir results # Download the results
-```
-
-After the download has finished you should see the following contents in the results directory.
-
-
-```bash
-%%bash
-ls results/outputs
-```
-
-The outputs include our trained model and the jupyter notebook with the output cells
diff --git a/docs/docs/examples/workload-onboarding/Sparkov-Data-Generation/index.md b/docs/docs/examples/workload-onboarding/Sparkov-Data-Generation/index.md
deleted file mode 100644
index 0a6b68fafe..0000000000
--- a/docs/docs/examples/workload-onboarding/Sparkov-Data-Generation/index.md
+++ /dev/null
@@ -1,223 +0,0 @@
----
-sidebar_label: "Sparkov Data Generation"
-sidebar_position: 11
----
-# Generate Synthetic Data using Sparkov Data Generation technique
-
-
-[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
-
-## Introduction
-
-A synthetic dataset is generated by algorithms or simulations which has similar characteristics to real-world data. Collecting real-world data, especially data that contains sensitive user data like credit card information, is not possible due to security and privacy concerns. If a data scientist needs to train a model to detect credit fraud they can use synthetically generated data instead of using real data without compromising the privacy of users.
-
-The advantage of using Bacalhau is that you can generate terabytes of synthetic data without having to install any dependencies or store the data locally.
-
-In this example, we will generate synthetic credit card transaction data using the Sparkov program and store the results in IPFS.
-
-## TD;LR
-Run Bacalhau on a synthetic dataset.
-
-## Prerequisite
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-## Running Sparkov Locally​
-
-To run Sparkov locally, you'll need to clone the repo and install dependencies.
-
-
-
-```bash
-%%bash
-git clone https://github.com/js-ts/Sparkov_Data_Generation/
-pip3 install -r Sparkov_Data_Generation/requirements.txt
-```
-
-Go to the Sparkov_Data_Generation directory
-
-
-```python
-%cd Sparkov_Data_Generation
-```
-
-Creating a temporary directory to store the outputs
-
-
-```bash
-%%bash
-mkdir ../outputs
-```
-
-## Running the script
-
-After the repo image has been pushed to Docker Hub, we can now use the container for running on Bacalhau. To submit a job, run the following Bacalhau command:
-
-
-```bash
-%%bash
-python3 datagen.py -n 1000 -o ../outputs "01-01-2022" "10-01-2022"
-```
-
-Below are some of the parameters you need before running the script
-
-- `-n`:  Number of customers to generate
-
-- `-o`: path to store the outputs
-
-- `Start date`: "01-01-2022"
-
-- `End date`: "10-01-2022"
-
-To see the full list of options, use:
-
-
-```bash
-%%bash
-python datagen.py -h
-```
-
-## Containerize Script using Docker
-
-:::info
-You can skip this entirely and directly go to running on Bacalhau.
-:::
-
-If you want any additional dependencies to be installed along with DuckDB, you need to build your own container.
-
-To build your own docker container, create a `Dockerfile`, which contains instructions to build your DuckDB docker container.
-
-
-```
-FROM python:3.8
-
-RUN apt update && apt install git
-
-RUN git clone https://github.com/js-ts/Sparkov_Data_Generation/
-
-WORKDIR /Sparkov_Data_Generation/
-
-RUN pip3 install -r requirements.txt
-```
-
-:::info
-See more information on how to containerize your script/app [here](https://docs.docker.com/get-started/02_our_app/)
-:::
-
-
-### Build the container
-
-We will run `docker build` command to build the container;
-
-```
-docker build -t <hub-user>/<repo-name>:<tag> .
-```
-
-Before running the command replace;
-
-- **hub-user** with your docker hub username, If you don’t have a docker hub account [follow these instructions to create Docker account](https://docs.docker.com/docker-id/), and use the username of the account you created
-
-- **repo-name** with the name of the container, you can name it anything you want
-
-- **tag** this is not required but you can use the latest tag
-
-In our case:
-
-```
-docker build -t jsacex/sparkov-data-generation
-```
-
-### Push the container
-
-Next, upload the image to the registry. This can be done by using the Docker hub username, repo name or tag.
-
-```
-docker push <hub-user>/<repo-name>:<tag>
-```
-
-In our case:
-
-```
-docker push jsacex/sparkov-data-generation
-```
-
-
-After the repo image has been pushed to Docker Hub, we can now use the container for running on Bacalhau
-
-## Running a Bacalhau Job
-
-
-Now we're ready to run a Bacalhau job. This code runs a job, downloads the results, and prints the stdout.
-
-Copy and paste the following code to your terminal
-
-
-```bash
-%%bash --out job_id
-bacalhau docker run \
---id-only \
---wait \
-jsacex/sparkov-data-generation \
---  python3 datagen.py -n 1000 -o ../outputs "01-01-2022" "10-01-2022"
-```
-
-### Structure of the command
-
-Let's look closely at the command above:
-
-* `bacalhau docker run`: call to bacalhau
-
-* `jsacex/sparkov-data-generation`: the name and the tag of the docker image we are using
-
-* `-o ../outputs "01-01-2022" "10-01-2022`:  path to store the outputs, start date and end-date.
-
-* `python3 datagen.py -n 1000`: execute Sparktov
-
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
-
-
-```python
-%env JOB_ID={job_id}
-```
-
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
-
-
-```bash
-%%bash
-bacalhau list --id-filter ${JOB_ID}
-```
-
-When it says `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
-
-
-
-```bash
-%%bash
-bacalhau describe ${JOB_ID}
-```
-
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
-
-
-```bash
-%%bash
-rm -rf results && mkdir -p results
-bacalhau get $JOB_ID --output-dir results
-```
-
-After the download has finished you should see the following contents in the results directory
-
-## Viewing your Job Output
-
-To view the file, run the following command:
-
-
-```bash
-%%bash
-ls results/outputs # list the contents of the current directory 
-```
diff --git a/docs/docs/examples/workload-onboarding/bacalhau-docker-image/index.md b/docs/docs/examples/workload-onboarding/bacalhau-docker-image/index.md
deleted file mode 100644
index 1f5319c4aa..0000000000
--- a/docs/docs/examples/workload-onboarding/bacalhau-docker-image/index.md
+++ /dev/null
@@ -1,182 +0,0 @@
----
-sidebar_label: "Bacalhau Docker Image"
-sidebar_position: 1
-description: How to use the Bacalhau Docker image
----
-# Bacalhau Docker Image
-
-
-[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
-
-This example shows you how to run some common client-side Bacalhau tasks using the Bacalhau Docker image.
-
-## TD;LR
-Running Docker image on Bacalhau
-
-## Prerequisites
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-
-```python
-!command -v bacalhau >/dev/null 2>&1 || (export BACALHAU_INSTALL_DIR=.; curl -sL https://get.bacalhau.org/install.sh | bash)
-path=!echo $PATH
-%env PATH=./:{path[0]}
-```
-
-## Pull the Docker image
-
-The first step is to pull the Bacalhau Docker image from the [Github container registry](https://github.com/orgs/bacalhau-project/packages/container/package/bacalhau).
-
-
-```bash
-%%bash
-docker pull ghcr.io/bacalhau-project/bacalhau:latest
-```
-
-    latest: Pulling from bacalhau-project/bacalhau
-    Digest: sha256:d80f1fe751886a29e0d5ae265a88abbfcd5c59e36247473b66aba93ea24f45aa
-    Status: Image is up to date for ghcr.io/bacalhau-project/bacalhau:latest
-    ghcr.io/bacalhau-project/bacalhau:latest
-
-
-You can also pull a specific version of the image, e.g.:
-
-```bash
-docker pull ghcr.io/bacalhau-project/bacalhau:v0.3.16
-```
-
-:::warning
-Remember that the "latest" tag is just a string. It doesn't refer to the latest version of the Bacalhau client, it refers to an image that has the "latest" tag. Therefore, if your machine has already downloaded the "latest" image, it won't download it again. To force a download, you can use the `--no-cache` flag.
-:::
-
-## Check version
-
-Check the version of the Bacalhau client you are using.
-
-
-
-```bash
-%%bash
-docker run -t ghcr.io/bacalhau-project/bacalhau:latest version
-```
-
-    Client Version: v0.3.29
-    Server Version: v0.3.29
-
-
-## Running a Bacalhau Job
-
-To submit a bi to Bacalhau, we use the `bacalhau docker run` command.
-
-
-```bash
-%%bash --out job_id
-docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
-    docker run \
-        --id-only \
-        --wait \
-        ubuntu:latest -- \
-            sh -c 'uname -a && echo "Hello from Docker Bacalhau!"'
-```
-
-In this example, I run an Ubuntu-based job that echo's some stuff.
-
-### Structure of the command
-
--  `--id-only......`: Output only the job id
-
-- `ubuntu:latest.` Ubuntu container
-
-- `ghcr.io/bacalhau-project/bacalhau:latest `: Name of the Bacalhau Docker image
-
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
-
-    env: JOB_ID=738e0b39-8f73-4f01-ab46-245e8479ad65
-
-
-To print out the content of the Job ID, run the following command:
-
-
-```bash
-%%bash
-docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
-    describe $JOB_ID \
-        | grep -A 2 "stdout: |"
-```
-
-          stdout: |
-            Linux 914f42609298 5.19.0-1022-gcp #24~22.04.1-Ubuntu SMP Sun Apr 23 09:51:08 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux
-            Hello from Docker Bacalhau!
-
-
-## Submit a Job With Output Files
-
-One inconvenience that you'll see is that you'll need to mount directories into the container to access files. This is because the container is running in a separate environment from your host machine. Let's take a look at the example below:
-
-The first part of the example should look familiar, except for the Docker commands.
-
-
-```bash
-%%bash --out job_id
-docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
-    docker run \
-        --id-only \
-        --wait \
-        --gpu 1 \
-        ghcr.io/bacalhau-project/examples/stable-diffusion-gpu:0.0.1 -- \
-            python main.py --o ./outputs --p "A Docker whale and a cod having a conversation about the state of the ocean"
-```
-
-
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
-
-    env: JOB_ID=bd141e1a-0f68-4a20-886f-c2b30c01b614
-
-
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
-
-
-```bash
-%%bash
-docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
-    list $JOB_ID \
-```
-
-When it says `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
-
-
-```bash
-%%bash
-docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
-    describe $JOB_ID \
-
-```
-
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
-
-
-```bash
-%%bash
-bacalhau get ${JOB_ID} --output-dir result
-```
-
-After the download has finished you should see the following contents in the results directory.
-
-
-
-
-
-![png](index_files/index_25_0.png)
-
-
-
-
-## Need Support?
-
-If have questions or need support or guidance, please reach out to the [Bacalhau team via Slack (#bacalhau channel)](https://filecoin.io/slack)
-
diff --git a/docs/docs/examples/workload-onboarding/r-hello-world/index.md b/docs/docs/examples/workload-onboarding/r-hello-world/index.md
deleted file mode 100644
index 4b59e4223e..0000000000
--- a/docs/docs/examples/workload-onboarding/r-hello-world/index.md
+++ /dev/null
@@ -1,137 +0,0 @@
----
-sidebar_label: "R Script"
-sidebar_position: 9
----
-# Running a Simple R Script in Bacalhau
-
-
-[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
-
-You can use official Docker containers for each language like R or Python. In this example, we will use the official R container and run it on Bacalhau.
-
-## TD;LR
-A quick guide on how to run a hello world script on Bacalhau
-
-## Prerequisites
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-## Running an R Script Locally
-
-To install R follow these instructions [A Installing R and RStudio | Hands-On Programming with R](https://rstudio-education.github.io/hopr/starting.html). After R and RStudio is installed, create and run a script called hello.R.
-
-
-```python
-%%writefile hello.R
-print("hello world")
-```
-
-Run the script:
-
-
-```bash
-%%bash
-Rscript hello.R
-```
-
-Next, upload the script to your public storage in our case IPFS.  We've already uploaded the script to IPFS and the CID is: `QmVHSWhAL7fNkRiHfoEJGeMYjaYZUsKHvix7L54SptR8ie`. You can look at this by browsing to one of the HTTP IPFS proxies like [ipfs.io](https://cloudflare-ipfs.com/ipfs/QmVHSWhAL7fNkRiHfoEJGeMYjaYZUsKHvix7L54SptR8ie/) or [w3s.link](https://w3s.link/ipfs/QmVHSWhAL7fNkRiHfoEJGeMYjaYZUsKHvix7L54SptR8ie).
-
-## Running a Job on Bacalhau
-
-Now it's time to run the script on the Bacalhau network. To run a job on Bacalhau, run the following command:
-
-
-```bash
-%%bash --out job_id
-bacalhau docker run \
---wait \
---id-only \
--i ipfs://QmQRVx3gXVLaRXywgwo8GCTQ63fHqWV88FiwEqCidmUGhk:/hello.R \
-r-base \
--- Rscript hello.R
-```
-
-### Structure of the command
-
-Let's look closely at the command above:
-
-* `bacalhau docker run`: call to bacalhau
-
-* `-i ipfs://QmQRVx3gXVLaRXywgwo8GCTQ63fHqWV88FiwEqCidmUGhk`: CIDs to use on the job. Mounts them at '/inputs' in the execution.
-
-* `:/hello.R`: the name and the tag of the docker image we are using
-
-* `Rscript hello.R`: execute the R script
-
-
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
-
-
-```python
-%env JOB_ID={job_id}
-```
-
-
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
-
-
-
-```bash
-%%bash
-bacalhau list --id-filter ${JOB_ID}
-```
-
-When it says `Published` or `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
-
-
-```bash
-%%bash
-bacalhau describe  ${JOB_ID}
-```
-
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
-
-
-```bash
-%%bash
-rm -rf results && mkdir results
-bacalhau get ${JOB_ID} --output-dir results
-```
-
-## Viewing your Job Output
-
-To view the file, run the following command:
-
-
-```bash
-%%bash
-ls results/
-```
-
-Viewing the result
-
-
-```bash
-%%bash
-cat results/stdout
-```
-
-### Futureproofing your R Scripts
-
-You can generate the job request with the following command. This will allow you to re-run that job in the future.
-
-
-```bash
-%%bash
-bacalhau describe ${JOB_ID} --spec > job.yaml
-```
-
-
-```bash
-%%bash
-cat job.yaml
-```
diff --git a/docs/docs/examples/workload-onboarding/trivial-python/index.md b/docs/docs/examples/workload-onboarding/trivial-python/index.md
deleted file mode 100644
index dd45ae180d..0000000000
--- a/docs/docs/examples/workload-onboarding/trivial-python/index.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-sidebar_label: "Python File"
-sidebar_position: 12
-description: How to run a Python file hosted on Bacalhau
----
-# Running a Python Script
-
-
-[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
-
-This example tutorial serves as an introduction to Bacalhau. Here, you'll be running a Python file hosted on a website on Bacalhau.
-
-## TD;LR
-A quick guide on how to run a hello world script on Bacalhau
-
-## Prerequisites
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-## Creating a Hello World File
-
-We'll be using a very simple Python script that displays the [traditional first greeting](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program).
-
-
-```python
-%cat hello-world.py
-```
-
-## Submit the workload
-
-To submit a workload to Bacalhau you can use the `bacalhau docker run` command.
-
-
-```bash
-%%bash --out job_id
-bacalhau docker run \
-  --id-only \
-  --input https://raw.githubusercontent.com/bacalhau-project/examples/151eebe895151edd83468e3d8b546612bf96cd05/workload-onboarding/trivial-python/hello-world.py \
-  python:3.10-slim -- python3 /inputs/hello-world.py
-```
-
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
-
-
-```python
-%env JOB_ID={job_id}
-```
-
-The `bacalhau docker run` command allows passing input data into the container using [content identifier (CID)](https://github.com/multiformats/cid) volumes, we will be using the `-i URL:path` [argument](https://docs.bacalhau.org/all-flags#docker-run) for simplicity. This results in Bacalhau mounting a *data volume* inside the container. By default, Bacalhau mounts the input volume at the path `/inputs` inside the container.
-
-:::info
-[Bacalhau overwrites the default entrypoint](https://github.com/filecoin-project/bacalhau/blob/v0.2.3/cmd/bacalhau/docker_run.go#L64), so we must run the full command after the `--` argument.
-:::
-
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
-
-
-```bash
-%%bash
-bacalhau list --id-filter=${JOB_ID} --no-style
-```
-
-When it says `Published` or `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
-
-
-```bash
-%%bash
-bacalhau describe ${JOB_ID}
-```
-
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
-
-
-```bash
-%%bash
-rm -rf results && mkdir results
-bacalhau get ${JOB_ID} --output-dir results
-```
-
-## Viewing your Job Output
-
-To view the file, run the following command:
-
-
-```bash
-
-%%bash
-cat results/stdout
-
-```
-
-## Need Support?
-
-For questions, and feedback, please reach out to our [forum](https://github.com/filecoin-project/bacalhau/discussions)
diff --git a/docs/docs/troubleshooting/faqs.md b/docs/docs/faqs.md
similarity index 99%
rename from docs/docs/troubleshooting/faqs.md
rename to docs/docs/faqs.md
index e1881bf79d..abcb3298e2 100644
--- a/docs/docs/troubleshooting/faqs.md
+++ b/docs/docs/faqs.md
@@ -1,6 +1,6 @@
 ---
 sidebar_label: 'FAQs'
-sidebar_position: 90
+sidebar_position: 6
 hide_title: true
 ---
 
diff --git a/docs/docs/getting-started/_category_.yml b/docs/docs/getting-started/_category_.yml
index 10f57dab68..dad78360bb 100644
--- a/docs/docs/getting-started/_category_.yml
+++ b/docs/docs/getting-started/_category_.yml
@@ -1,2 +1,2 @@
-label: "Getting Started"
+label: "Quick Start"
 position: 2
diff --git a/docs/docs/getting-started/architecture.md b/docs/docs/getting-started/architecture.md
index 608ffb26c2..99a72cd562 100644
--- a/docs/docs/getting-started/architecture.md
+++ b/docs/docs/getting-started/architecture.md
@@ -1,135 +1,454 @@
 ---
-sidebar_label: 'Architecture'
+sidebar_label: 'How Bacalhau Works'
 sidebar_position: 1
 ---
 
-# Architecture
+# How Bacalhau Works
+In this tutorial we will go over the components and the architecture of Bacalhau. You will learn how it is built, what components are used, how you could interact and how you could use Bacalhau.
+## Chapter 1 - Architecture
 
-Bacalhau is a peer-to-peer network of nodes that allows for decentralized communication between computers. There are two nodes types in the network:
-- **Requester Node:** responsible for handling user requests, discovering and ranking compute nodes, forwarding jobs to compute nodes, and monitoring the job lifecycle.
-- **Compute Node:** responsible for executing jobs and producing results. Different compute nodes can be used for different types of jobs, depending on their capabilities and resources.
+Bacalhau is a peer-to-peer network of nodes that enables decentralized communication between computers. The network consists of two types of nodes, which can communicate with each other.
 
-![image](../../static/img/architecture/architecture-purpose.jpg 'Bacalhau Architecture')
+![image](../../static/img/architecture/architecture-overview.webp 'Bacalhau Architecture')
 
-The requester and compute nodes together form a p2p network and use gossiping to discover each other, share information about node capabilities, available resources and health status.
+The requester and compute nodes together form a p2p network and use gossiping to discover each other, share information about node capabilities, available resources and health status. Bacalhau is a peer-to-peer network of nodes that enables decentralized communication between computers.  
+:::info
+  **Requester Node:** responsible for handling user requests, discovering and ranking compute nodes, forwarding jobs to compute nodes, and monitoring the job lifecycle.  
 
-To interact with the Bacalhau network, users can use the Bacalhau CLI (command-line interface) to send requests to a requester node in the network. These requests are sent using the JSON format over HTTP, a widely-used protocol for transmitting data over the internet.
+  **Compute Node:** responsible for executing jobs and producing results. Different compute nodes can be used for different types of jobs, depending on their capabilities and resources.
+:::
 
-## System Components
+To interact with the Bacalhau network, users can use the Bacalhau CLI (command-line interface) to send requests to a requester node in the network. These requests are sent using the JSON format over HTTP, a widely-used protocol for transmitting data over the internet. Bacalhau's architecture involves two main sections which are the **core components** and **interfaces**.
 
-Bacalhau's architecture involves two main sections which are the **core components** and **interfaces**.
+<details>
+  <summary>Components overview</summary>
+  <div>
+    <div>![image](../../static/img/architecture/System-Components.png 'System-Components')</div>
+  </div>
+</details>
 
-## Core Components
 
-The core components are responsible for handling requests and connecting different nodes. It consists of:
+### Core Components
 
-- [Requester node](#requester-node)
-- [Compute node](#compute-node)
+The core components are responsible for handling requests and connecting different nodes. The network includes two different components:
 
-### Requester node
+<details>
+  <summary>Requester node</summary>
+  <div>
+    <div>In the Bacalhau network, the requester node is responsible for handling requests from clients using `JSON` over `HTTP`. This node serves as the main custodian of jobs that are submitted to it. When a job is submitted to a requester node, it selects compute nodes that are capable and suitable to execute the job, and coordinates the job execution.</div>
+  </div>
+</details>
 
-In the Bacalhau network, the requester node is responsible for handling requests from clients using JSON over HTTP. This node serves as the main custodian of jobs that are submitted to it.
+<details>
+  <summary>Compute node</summary>
+  <div>
+    <div>In the Bacalhau network, it is the compute node that is responsible for determining whether it can execute a job or not. This model allows for a more decentralized approach to job orchestration as the network will function properly even if the requester nodes have stale view of the network, or if concurrent requesters are allocating jobs to the same compute nodes. Once the compute node has run the job and produced results, it will publish the results to a remote destination as specified in the job specification (e.g. `S3`), and notify the requester of the job completion. The compute node has a collection of named executors, storage sources, and publishers, and it will choose the most appropriate ones based on the job specifications.</div>
+  </div>
+</details>
 
-When a job is submitted to a requester node, it selects compute nodes that are capable and suitable to execute the job, and communicate with them directly. It is important to note that there is only ever a single requester node for a given job, which is the node that the job was originally submitted to.
+### Interfaces
 
-Overall, the requester node plays a crucial role in the Bacalhau network, serving as the main point of contact for clients and the primary handler of jobs that are submitted to the network.
+The interfaces handle the distribution, execution, storage and publishing of jobs. In the following all the different components are described and their respective protocols are shown.
 
-### Compute node
+<details>
+  <summary>Transport</summary>
+  <div>
+    <div>The transport interface is responsible for sending messages about jobs that are created, accepted, and executed  to other compute nodes. It also manages the identity of individual Bacalhau nodes to ensure that messages are only delivered to authorized nodes, which improves network security. To achieve this, the transport interface uses a protocol called `bprotocol`, which is a point-to-point scheduling protocol that runs over [`libp2p`](https://libp2p.io/) and is used to distribute job messages efficiently to other nodes on the network. This is our upgrade to the [`GossipSub`](https://docs.libp2p.io/concepts/publish-subscribe/) handler as it ensures that messages are delivered to the right nodes without causing network congestion, thereby making communication between nodes more scalable and efficient.</div>
+  </div>
+</details>
 
-In the Bacalhau network, the compute node plays a critical role in the process of executing jobs and producing results. While the requester does its best to be up-to-date with the network status, it is the compute node that is responsible for determining whether it can execute a job or not. This model allows for a more decentralized approach to job orchestration as the network will function properly even if the requester nodes have stale view of the network, or if concurrent requesters are allocating jobs to the same compute nodes. 
+<details>
+  <summary>Executor</summary>
+  <div>
+    <div>The executor is a critical component of the Bacalhau network that handles the execution of jobs and ensures that the storage used by the job is local. One of its main responsibilities is to present the input and output storage volumes into the job when it is run. The executor performs two primary functions: presenting the storage volumes in a format that is suitable for the executor and running the job. When the job is completed, the executor will merge the `stdout`, `stderr` and named output volumes into a results folder that is then published to a remote location. Overall, the executor plays a crucial role in the Bacalhau network by ensuring that jobs are executed properly, and their results are published accurately.</div>
+  </div>
+</details>
 
-Once the compute node has run the job and produced results, it will publish the results to a remote destination as specified in the job specification (e.g. S3), and notify the requester of the job completion. The compute node has a collection of named executors, storage sources, and publishers, and it will choose the most appropriate ones based on the job specifications.
+<details>
+  <summary>Storage Provider</summary>
+  <div>
+    <div>In a peer-to-peer network like Bacalhau, storage providers play a crucial role in presenting an upstream storage source. There can be different storage providers available in the network, each with its own way of manifesting the `CID (Content IDentifier)` to the executor. For instance, there can be a `POSIX` storage provider that presents the `CID` as a `POSIX` filesystem, or a library storage provider that streams the contents of the `CID` via a library call. Therefore, the storage providers and Executor implementations are loosely coupled, allowing the `POSIX` and library storage providers to be used across multiple executors, wherever it is deemed appropriate.</div>
+  </div>
+</details>
 
-## Interface
+<details>
+  <summary>Publisher</summary>
+  <div>
+    <div>The publisher is responsible for uploading the final results of a job to a remote location where clients can access them, such as S3 or IPFS.</div>
+  </div>
+</details>
 
-The interface handles the distribution, execution, storage and publishing of jobs.
 
-- [Transport](#transport)
-- [Executor](#executor)
-- [Storage Provider](#storage-provider)
-- [Verifier](#verifier)
-- [Publisher](#publisher)
+## Chapter 2 - Job cycle
 
-### Transport
+### Job preparation
 
-The transport interface is responsible for sending messages about jobs that are created, accepted, and executed  to other compute nodes. It also manages the identity of individual Bacalhau nodes to ensure that messages are only delivered to authorized nodes, which improves network security.
+You can create jobs in the Bacalhau network using various [job types](../setting-up/jobs/job-types.md) introduced in version 1.2. Each job may need specific variables, resource requirements and data details that are described in the [Job Specification](../setting-up/jobs/job-specification/index.md).
 
-To achieve this, the transport interface uses a protocol called **bprotocol**, which is a point-to-point scheduling protocol that runs over [libp2p](https://libp2p.io/) and is used to distribute job messages efficiently to other nodes on the network. This is our upgrade to the [GossipSub](https://docs.libp2p.io/concepts/publish-subscribe/) handler as it ensures that messages are delivered to the right nodes without causing network congestion, thereby making communication between nodes more scalable and efficient.
+<details>
+  <summary>Advanced job preparation</summary>
+  <div>
+    <div>
+        Prepare data with Bacalhau by [copying from URLs](../setting-up/data-ingestion/from-url.md),
+       [pinning to public storage](../setting-up/data-ingestion/pin.md), or [copying from an S3 bucket](../setting-up/data-ingestion/s3.md). Mount data anywhere for Bacalhau to run against. Refer to [IPFS](../setting-up/other-specifications/sources/ipfs.md), [Local](../setting-up/other-specifications/sources/local.md), [S3](../setting-up/other-specifications/sources/s3.md), and [URL](../setting-up/other-specifications/sources/url.md) Source Specifications for data source usage.
 
-### Executor
+        Optimize workflows without completely redesigning them. Run arbitrary tasks using Docker containers and WebAssembly images. Follow the Onboarding guides for [Docker](../getting-started/docker-workload-onboarding.md) and [WebAssembly](../getting-started/wasm-workload-onboarding.md) workloads.
 
-The executor is a critical component of the Bacalhau network that handles the execution of jobs and ensures that the storage used by the job is local. One of its main responsibilities is to present the input and output storage volumes into the job when it is run.
+        Explore GPU workload support with Bacalhau. Learn how to run GPU workloads using the Bacalhau client in the [GPU Workloads](../getting-started/resources.md#gpu-setup) section. Integrate Python applications with Bacalhau using the [Bacalhau Python SDK](../integration/python-sdk.md).
 
-The executor performs two primary functions: 
-- presenting the storage volumes in a format that is suitable for the executor, and,
-- running the job.
+        For node operation, refer to the [Running a Node](../setting-up/running-node/quick-start.md) section for configuring and running a Bacalhau node. If you prefer an isolated environment, explore the [Private Cluster](../setting-up/networking-instructions/private-cluster.md) for performing tasks without connecting to the main Bacalhau network.
+    </div>
+  </div>
+</details>
 
-When the job is completed, the executor will merge the stdout, stderr, and named output volumes into a results folder that is then published to a remote location.
+### Job Submission
 
-Overall, the executor plays a crucial role in the Bacalhau network by ensuring that jobs are executed properly, and their results are published accurately.
+You should use the Bacalhau client to send a task to the network.
+The client transmits the job information to the Bacalhau network via established protocols and interfaces. 
+Jobs submitted via the Bacalhau CLI are forwarded to a Bacalhau network node at http://bootstrap.production.bacalhau.org/ via port 1234 by default. This Bacalhau node will act as the requester node for the duration of the job lifecycle.
+
+Bacalhau provides an interface to interact with the server via a REST API. Bacalhau uses 127.0.0.1 as the localhost and 1234 as the port by default.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs
+defaultValue="CLI"
+values={[
+{label: 'CLI', value: 'CLI'},
+{label: 'API', value: 'API'},
+]}>
+<TabItem value="CLI">
+
+    ```shell
+    bacalhau create [flags]
+    ```
+
+You can use the command with [appropriate flags](../dev/cli-reference/all-flags.md#create) to create a job in Bacalhau using JSON and YAML formats.
+
+</TabItem>
+<TabItem value="API">
+    ```
+    Endpoint: `PUT /api/v1/orchestrator/jobs`
+    ```
+
+    You can use [Create Job API Documentation](../dev/api/jobs.md#create-job) to submit a new job for execution.
+
+</TabItem>
+</Tabs>
+
+You can use the `bacalhau docker run` [command](../dev/cli-reference/all-flags.md#docker-run) to start a job in a Docker container. Below, you can see an excerpt of the commands:
+
+<details>
+  <summary>Bacalhau Docker CLI commands</summary>
+  <div>
+    <div>
+        ```shell
+            Usage:
+            bacalhau docker run [flags] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]
+
+            Flags:
+                 --concurrency int                  How many nodes should run the job (default 1)
+                 --cpu string                       Job CPU cores (e.g. 500m, 2, 8).
+                 --disk string                      Job Disk requirement (e.g. 500Gb, 2Tb, 8Tb).
+                 --do-not-track                     When true the job will not be tracked(?) TODO BETTER DEFINITION
+                 --domain stringArray               Domain(s) that the job needs to access (for HTTP networking)
+                 --download                         Should we download the results once the job is complete?
+                 --download-timeout-secs duration   Timeout duration for IPFS downloads. (default 5m0s)
+                 --dry-run                          Do not submit the job, but instead print out what will be submitted
+                 --entrypoint strings               Override the default ENTRYPOINT of the image
+             -e, --env strings                      The environment variables to supply to the job (e.g. --env FOO=bar --env BAR=baz)
+             -f, --follow                           When specified will follow the output from the job as it runs
+             -g, --gettimeout int                   Timeout for getting the results of a job in --wait (default 10)
+                 --gpu string                       Job GPU requirement (e.g. 1, 2, 8).
+             -h, --help                             help for run
+                 --id-only                          Print out only the Job ID on successful submission.
+             -i, --input storage                    Mount URIs as inputs to the job. Can be specified multiple times. Format: src=URI,dst=PATH[,opt=key=value]
+                                                  Examples:
+                                                  # Mount IPFS CID to /inputs directory
+                                                  -i ipfs://QmeZRGhe4PmjctYVSVHuEiA9oSXnqmYa4kQubSHgWbjv72
+                                                  # Mount S3 object to a specific path
+                                                  -i s3://bucket/key,dst=/my/input/path
+                                                  # Mount S3 object with specific endpoint and region
+                                                  -i src=s3://bucket/key,dst=/my/input/path,opt=endpoint=https://s3.example.com,opt=region=us-east-1
+                 --ipfs-connect string              The ipfs host multiaddress to connect to, otherwise an in-process IPFS node will be created if not set.
+                 --ipfs-serve-path string           path local Ipfs node will persist data to
+                 --ipfs-swarm-addrs strings         IPFS multiaddress to connect the in-process IPFS node to - cannot be used with --ipfs-connect. (default [/ip4/35.245.161.250/tcp/4001/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/35.245.161.250/udp/4001/quic/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/34.86.254.26/tcp/4001/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/34.86.254.26/udp/4001/quic/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/35.245.215.155/tcp/4001/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/35.245.215.155/udp/4001/quic/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/34.145.201.224/tcp/4001/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/34.145.201.224/udp/4001/quic/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/35.245.41.51/tcp/4001/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa,/ip4/35.245.41.51/udp/4001/quic/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa])
+                 --ipfs-swarm-key string            Optional IPFS swarm key required to connect to a private IPFS swarm
+             -l, --labels strings                   List of labels for the job. Enter multiple in the format '-l a -l 2'. All characters not matching /a-zA-Z0-9_:|-/ and all emojis will be stripped.
+                 --memory string                    Job Memory requirement (e.g. 500Mb, 2Gb, 8Gb).
+                 --network network-type             Networking capability required by the job. None, HTTP, or Full (default None)
+                 --node-details                     Print out details of all nodes (overridden by --id-only).
+             -o, --output strings                   name:path of the output data volumes. 'outputs:/outputs' is always added unless '/outputs' is mapped to a different name. (default [outputs:/outputs])
+                 --output-dir string                Directory to write the output to.
+                 --private-internal-ipfs            Whether the in-process IPFS node should auto-discover other nodes, including the public IPFS network - cannot be used with --ipfs-connect. Use "--private-internal-ipfs=false" to disable. To persist a local Ipfs node, set BACALHAU_SERVE_IPFS_PATH to a valid path. (default true)
+             -p, --publisher publisher              Where to publish the result of the job (default ipfs)
+                 --raw                              Download raw result CIDs instead of merging multiple CIDs into a single result
+             -s, --selector string                  Selector (label query) to filter nodes on which this job can be executed, supports '=', '==', and '!='.(e.g. -s key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints.
+                 --target all|any                   Whether to target the minimum number of matching nodes ("any") (default) or all matching nodes ("all") (default any)
+                 --timeout int                      Job execution timeout in seconds (e.g. 300 for 5 minutes)
+                 --wait                             Wait for the job to finish. Use --wait=false to return as soon as the job is submitted. (default true)
+                 --wait-timeout-secs int            When using --wait, how many seconds to wait for the job to complete before giving up. (default 600)
+             -w, --workdir string                   Working directory inside the container. Overrides the working directory shipped with the image (e.g. via WORKDIR in Dockerfile).
+        ```
+    </div>
+  </div>
+</details>
+
+
+You can also use the `bacalhau wasm run` [command](../dev/cli-reference/all-flags.md#wasm) to run a job compiled into the (WASM) format. Below, you can find an excerpt of the commands in the Bacalhau CLI:
+
+<details>
+  <summary>Bacalhau WASM CLI commands</summary>
+  <div>
+    <div>
+        ```shell
+            Usage:
+            bacalhau wasm run {cid-of-wasm | <local.wasm>} [--entry-point <string>] [wasm-args ...] [flags]
+
+            Flags:
+                    --concurrency int                  How many nodes should run the job (default 1)
+                    --cpu string                       Job CPU cores (e.g. 500m, 2, 8).
+                    --disk string                      Job Disk requirement (e.g. 500Gb, 2Tb, 8Tb).
+                    --do-not-track                     When true the job will not be tracked(?) TODO BETTER DEFINITION
+                    --domain stringArray               Domain(s) that the job needs to access (for HTTP networking)
+                    --download                         Should we download the results once the job is complete?
+                    --download-timeout-secs duration   Timeout duration for IPFS downloads. (default 5m0s)
+                    --dry-run                          Do not submit the job, but instead print out what will be submitted
+                    --entry-point string               The name of the WASM function in the entry module to call. This should be a zero-parameter zero-result function that
+                                         		will execute the job. (default "_start")
+                -e, --env strings                      The environment variables to supply to the job (e.g. --env FOO=bar --env BAR=baz)
+                -f, --follow                           When specified will follow the output from the job as it runs
+                -g, --gettimeout int                   Timeout for getting the results of a job in --wait (default 10)
+                    --gpu string                       Job GPU requirement (e.g. 1, 2, 8).
+                -h, --help                             help for run
+                    --id-only                          Print out only the Job ID on successful submission.
+                -U, --import-module-urls url           URL of the WASM modules to import from a URL source. URL accept any valid URL supported by the 'wget' command, and supports both HTTP and HTTPS.
+                -I, --import-module-volumes cid:path   CID:path of the WASM modules to import from IPFS, if you need to set the path of the mounted data.
+                -i, --input storage                    Mount URIs as inputs to the job. Can be specified multiple times. Format: src=URI,dst=PATH[,opt=key=value]
+                                                     Examples:
+                                                     # Mount IPFS CID to /inputs directory
+                                                     -i ipfs://QmeZRGhe4PmjctYVSVHuEiA9oSXnqmYa4kQubSHgWbjv72
+                                                     # Mount S3 object to a specific path
+                                                     -i s3://bucket/key,dst=/my/input/path
+                                                     # Mount S3 object with specific endpoint and region
+                                                     -i src=s3://bucket/key,dst=/my/input/path,opt=endpoint=https://s3.example.com,opt=region=us-east-1
+                    --ipfs-connect string              The ipfs host multiaddress to connect to, otherwise an in-process IPFS node will be created if not set.
+                    --ipfs-serve-path string           path local Ipfs node will persist data to
+                    --ipfs-swarm-addrs strings         IPFS multiaddress to connect the in-process IPFS node to - cannot be used with --ipfs-connect. (default [/ip4/35.245.161.250/tcp/4001/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/35.245.161.250/udp/4001/quic/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/34.86.254.26/tcp/4001/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/34.86.254.26/udp/4001/quic/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/35.245.215.155/tcp/4001/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/35.245.215.155/udp/4001/quic/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/34.145.201.224/tcp/4001/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/34.145.201.224/udp/4001/quic/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/35.245.41.51/tcp/4001/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa,/ip4/35.245.41.51/udp/4001/quic/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa])
+                    --ipfs-swarm-key string            Optional IPFS swarm key required to connect to a private IPFS swarm
+                -l, --labels strings                   List of labels for the job. Enter multiple in the format '-l a -l 2'. All characters not matching /a-zA-Z0-9_:|-/ and all emojis will be stripped.
+                    --memory string                    Job Memory requirement (e.g. 500Mb, 2Gb, 8Gb).
+                    --network network-type             Networking capability required by the job. None, HTTP, or Full (default None)
+                    --node-details                     Print out details of all nodes (overridden by --id-only).
+                -o, --output strings                   name:path of the output data volumes. 'outputs:/outputs' is always added unless '/outputs' is mapped to a different name. (default [outputs:/outputs])
+                    --output-dir string                Directory to write the output to.
+                    --private-internal-ipfs            Whether the in-process IPFS node should auto-discover other nodes, including the public IPFS network - cannot be used with --ipfs-connect. Use "--private-internal-ipfs=false" to disable. To persist a local Ipfs node, set BACALHAU_SERVE_IPFS_PATH to a valid path. (default true)
+                -p, --publisher publisher              Where to publish the result of the job (default ipfs)
+                    --raw                              Download raw result CIDs instead of merging multiple CIDs into a single result
+                -s, --selector string                  Selector (label query) to filter nodes on which this job can be executed, supports '=', '==', and '!='.(e.g. -s key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints.
+                    --target all|any                   Whether to target the minimum number of matching nodes ("any") (default) or all matching nodes ("all") (default any)
+                    --timeout int                      Job execution timeout in seconds (e.g. 300 for 5 minutes)
+                    --wait                             Wait for the job to finish. Use --wait=false to return as soon as the job is submitted. (default true)
+                    --wait-timeout-secs int            When using --wait, how many seconds to wait for the job to complete before giving up. (default 600)
+        ```
+    </div>
+  </div>
+</details>
 
-### Storage Provider
+### Job Acceptance
 
-In a peer-to-peer network like Bacalhau, storage providers play a crucial role in presenting an upstream storage source. There can be different storage providers available in the network, each with its own way of manifesting the CID (Content IDentifier) to the executor.
+When a job is submitted to a requester node, it selects compute nodes that are capable and suitable to execute the job, and communicate with them directly. The compute node has a collection of named executors, storage sources, and publishers, and it will choose the most appropriate ones based on the job specifications. 
 
-For instance, there can be a POSIX storage provider that presents the CID as a POSIX filesystem, or a library storage provider that streams the contents of the CID via a library call.
+### Job execution
 
-Therefore, the storage providers and Executor implementations are loosely coupled, allowing the POSIX and library storage providers to be used across multiple executors, wherever it is deemed appropriate.
+The selected compute node receives the job and starts its execution inside a container. The container can use different executors to work with the data and perform the necessary actions.  A job can use the docker executor, WASM executor or a library storage volumes. Use [Docker Engine Specification](../setting-up/other-specifications/engines/docker.md) to view the parameters to configure the Docker Engine. If you want tasks to be executed in a WebAssembly environment, pay attention to [WebAssembly Engine Specification](../setting-up/other-specifications/engines/wasm.md).
 
-### Publisher
+### Results publishing
 
-The publisher is responsible for uploading the final results of a job to a remote location where clients can access them, such as S3 or IPFS
+When the Compute node completes the job, it publishes the results to **S3's remote storage**, **IPFS**.
 
-## Job Lifecycle
+Bacalhau's seamless integration with IPFS ensures that users have a decentralized option for publishing their task results, enhancing accessibility and resilience while reducing dependence on a single point of failure. View [IPFS Publisher Specification](../setting-up/other-specifications/publishers/ipfs.md) to get the detailed information.
 
-The job lifecycle involves several steps that are handled by different components of the network, from job submission to job download.
+Bacalhau's S3 Publisher provides users with a secure and efficient method to publish task results to any S3-compatible storage service. This publisher supports not just AWS S3, but other S3-compatible services offered by cloud providers like Google Cloud Storage and Azure Blob Storage, as well as open-source options like MinIO. View [S3Publisher Specification](../setting-up/other-specifications/publishers/s3.md) to get the detailed information.
 
-### Job Submission
+## Chapter 3 - Returning Information
 
-Jobs submitted via the Bacalhau CLI are forwarded to a Bacalhau network node at `bootstrap.production.bacalhau.org` via port 1234 by default. This Bacalhau node will act as the requester node for the duration of the job lifecycle. Jobs can also be submitted to any requester node on the Bacalhau network.
+The Bacalhau client receives updates on the task execution status and results. A user can access the results and manage tasks through the command line interface.
 
-When jobs are submitted to the requester node, the requester will select few compute nodes that are capable to execute the job and ask them to run. The job will have a `concurrency` setting, which refers to how many different nodes you may want to run this job.  
+### Get Job Results
 
-The job might also mention the use of `volumes` (for example some CIDs). The compute node can choose to bid on the job if the data for the volume resides locally in the compute node, or it can choose to bid anyway. Bacalhau supports the use of external HTTP or exec hooks to decide if a node wants to bid on a job. This means that a node operator can give granular rules about the jobs they are willing to run.
+To Get the results of a job you can run `bacalhau get [id] [flags]`
 
+```shell
+Usage:
+  bacalhau get [id] [flags]
 
-### Job Acceptance
+Flags:
+      --download-timeout-secs duration   Timeout duration for IPFS downloads. (default 5m0s)
+  -h, --help                             help for get
+      --ipfs-connect string              The ipfs host multiaddress to connect to, otherwise an in-process IPFS node will be created if not set.
+      --ipfs-serve-path string           path local Ipfs node will persist data to
+      --ipfs-swarm-addrs strings         IPFS multiaddress to connect the in-process IPFS node to - cannot be used with --ipfs-connect. (default [/ip4/35.245.161.250/tcp/4001/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/35.245.161.250/udp/4001/quic/p2p/12D3KooWAQpZzf3qiNxpwizXeArGjft98ZBoMNgVNNpoWtKAvtYH,/ip4/34.86.254.26/tcp/4001/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/34.86.254.26/udp/4001/quic/p2p/12D3KooWLfFBjDo8dFe1Q4kSm8inKjPeHzmLBkQ1QAjTHocAUazK,/ip4/35.245.215.155/tcp/4001/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/35.245.215.155/udp/4001/quic/p2p/12D3KooWH3rxmhLUrpzg81KAwUuXXuqeGt4qyWRniunb5ipjemFF,/ip4/34.145.201.224/tcp/4001/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/34.145.201.224/udp/4001/quic/p2p/12D3KooWBCBZnXnNbjxqqxu2oygPdLGseEbfMbFhrkDTRjUNnZYf,/ip4/35.245.41.51/tcp/4001/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa,/ip4/35.245.41.51/udp/4001/quic/p2p/12D3KooWJM8j97yoDTb7B9xV1WpBXakT4Zof3aMgFuSQQH56rCXa])
+      --ipfs-swarm-key string            Optional IPFS swarm key required to connect to a private IPFS swarm
+      --output-dir string                Directory to write the output to.
+      --private-internal-ipfs            Whether the in-process IPFS node should auto-discover other nodes, including the public IPFS network - cannot be used with --ipfs-connect. Use "--private-internal-ipfs=false" to disable. To persist a local Ipfs node, set BACALHAU_SERVE_IPFS_PATH to a valid path. (default true)
+      --raw                              Download raw result CIDs instead of merging multiple CIDs into a single result
+```
 
-As bids from compute nodes arrive back at the originating requester node, it can choose which bids to accept and which ones to reject. This can be based on the previous reputation of each compute node or any other factors the requester node might take into account (like locality, hardware resources, cost etc). The requester node will also have the same http or exec hooks to decide if it wants to accept a bid from a given compute node. 
+### Describe a Job
 
+<Tabs
+defaultValue="CLI"
+values={[
+{label: 'CLI', value: 'CLI'},
+{label: 'API', value: 'API'},
+]}>
+<TabItem value="CLI">
 
-### Job Execution
+    ```shell
+    bacalhau describe [id] [flags]
+    ```
 
-As accepted bids are received by compute nodes, they will `execute` the job using the executor for that job, and the storage providers that the executor has mapped in.
+    You can use the command with [appropriate flags](../dev/cli-reference/all-flags.md#describe) to get a full description of a job in yaml format.
 
-For example, a job could use the `docker` executor, `WASM` executor, or a library storage volumes. This would result in a POSIX mount of the storage into a running container or a WASM-style `syscall` to stream the storage bytes into the WASM runtime. Each executor will deal with storage in a different way, so even though each job mentions the storage volumes, they would both end up with different implementations at runtime.
+</TabItem>
+<TabItem value="API">
 
+    Endpoint: `GET /api/v1/orchestrator/jobs/:jobID`
 
+    You can use [Describe Job API Documentation](../dev/api/jobs.md#describe-job) to retrieve the specification and current status of a particular job. 
 
-### Publishing
+</TabItem>
+</Tabs>
 
-Once results are ready, the publisher will publish the raw results folder currently residing on the compute node. The publisher interface mainly consists of a single function, which has the task of uploading the local results folder somewhere and returning a storage reference to where it has been uploaded.
 
+### List of Jobs
 
-### Networking
+<Tabs
+defaultValue="CLI"
+values={[
+{label: 'CLI', value: 'CLI'},
+{label: 'API', value: 'API'},
+]}>
+<TabItem value="CLI">
 
-It is possible to run Bacalhau completely disconnected from the main Bacalhau network so that you can run private workloads without risking running on public nodes or inadvertently sharing your data outside of your organization. The isolated network will not connect to the public Bacalhau network nor connect to a public network. Read more on [networking](https://docs.bacalhau.org/next-steps/private-cluster)
+    ```shell
+    bacalhau list [flags]
+    ```
 
+    You can use the command with [appropriate flags](../dev/cli-reference/all-flags.md#list-2) to list jobs on the network in yaml format.
 
-### Input / Output Volumes
+</TabItem>
+<TabItem value="API">
 
-A job includes the concept of input and output volumes, and the Docker executor implements support for these. This means you can specify your CIDs, URLs, and/or S3 objects as input paths and also write results to an output volume. This can be seen in the following example:
+    Endpoint: `GET /api/v1/orchestrator/jobs`
 
-```
-bacalhau docker run \
-  -i s3://mybucket/logs-2023-04*:/input \
-  -o apples:/output_folder \
-  ubuntu \
-  bash -c 'ls /input > /output_folder/file.txt'
-```
+    You can use [List Jobs API Documentation](../dev/api/jobs.md#list-jobs) to retrieve a list of jobs.
+
+</TabItem>
+</Tabs>
+
+ 
+### Job Executions
+
+<Tabs
+defaultValue="CLI"
+values={[
+{label: 'CLI', value: 'CLI'},
+{label: 'API', value: 'API'},
+]}>
+<TabItem value="CLI">
+
+    ```shell
+    bacalhau job executions [id] [flags]
+    ```
+
+    You can use the command with [appropriate flags](../dev/cli-reference/all-flags.md#executions) to list all executions associated with a job, identified by its ID, in yaml format.
+
+</TabItem>
+<TabItem value="API">
+
+    Endpoint: `GET /api/v1/orchestrator/jobs/:jobID/executions`
+
+    You can use [Job Executions API Documentation](../dev/api/jobs.md#job-executions) to retrieve all executions for a particular job.
+
+</TabItem>
+</Tabs>
+
+ 
+## Chapter 4 - Monitoring and Management
+
+The Bacalhau client provides the user with tools to monitor and manage the execution of jobs. You can get information about status, progress and decide on next steps.
+View the  [Bacalhau Agent APIs](../dev/api/agent.md) if you want to know the node's health, capabilities, and deployed Bacalhau version. 
+To get information about the status and characteristics of the nodes in the cluster use [Nodes API Documentation](../dev/api/nodes.md).
+
+
+### Stop a Job
 
-The above example demonstrates an input volume flag `-i s3://mybucket/logs-2023-04*`, which mounts all S3 objects in bucket `mybucket` with `logs-2023-04` prefix within the docker container at location `/input` (root).
 
-Output volumes are mounted to the Docker container at the location specified. In the example above, any content written to `/output_folder` will be made available within the "apples" folder in the job results CID.
+<Tabs
+defaultValue="CLI"
+values={[
+{label: 'CLI', value: 'CLI'},
+{label: 'API', value: 'API'},
+]}>
+<TabItem value="CLI">
+
+    ```shell
+    bacalhau cancel [id] [flags]
+    ```
+
+    You can use the command with [appropriate flags](../dev/cli-reference/all-flags.md#cancel) to cancel a job that was previously submitted and stop it running if it has not yet completed.
+
+</TabItem>
+<TabItem value="API">
+
+    Endpoint: `DELETE /api/v1/orchestrator/jobs/:jobID`
+
+    You can use [Stop Job API Documentation](../dev/api/jobs.md#stop-job) to terminate a specific job asynchronously.
+
+</TabItem>
+</Tabs>
+
+ 
+### Job History
+
+
+<Tabs
+defaultValue="CLI"
+values={[
+{label: 'CLI', value: 'CLI'},
+{label: 'API', value: 'API'},
+]}>
+<TabItem value="CLI">
+
+     ```shell
+    bacalhau job history [id] [flags]
+    ```
+
+    You can use the command with [appropriate flags](../dev/cli-reference/all-flags.md#history) to enumerate the historical events related to a job, identified by its ID.
+
+</TabItem>
+<TabItem value="API">
+
+    Endpoint: `GET /api/v1/orchestrator/jobs/:jobID/history`
+
+    You can use [Job History API Documentation](../dev/api/jobs.md#job-history) to retrieve historical events for a specific job.
+
+</TabItem>
+</Tabs>
+
+ 
+### Job Logs
+
+
+```shell
+bacalhau logs [flags] [id]
+```
+
+You can use this [command](../dev/cli-reference/all-flags.md#logs-1) to retrieve the log output (stdout, and stderr) from a job. If the job is still running it is possible to follow the logs after the previously generated logs are retrieved. 
 
-Once the job has run on the executor, the contents of `stdout` and `stderr` will be added to any named output volumes the job has used (in this case apples), and all those entities will be packaged into the results folder which is then published to a remote location by the publisher.
+:::info
+ To familiarize yourself with all the commands used in Bacalhau, please view [CLI Commands](../dev/cli-reference/all-flags.md)
+ :::
diff --git a/docs/docs/getting-started/docker-workload-onboarding.md b/docs/docs/getting-started/docker-workload-onboarding.md
index 47414f9855..73510dffd8 100644
--- a/docs/docs/getting-started/docker-workload-onboarding.md
+++ b/docs/docs/getting-started/docker-workload-onboarding.md
@@ -1,29 +1,34 @@
 ---
-sidebar_label: 'Onboard Docker Workload'
+sidebar_label: 'Workloads (Docker)'
 sidebar_position: 3
 description: How to use docker containers with Bacalhau
 ---
 import ReactPlayer from 'react-player'
 
-# Onboarding Your Docker Workloads
+# Docker Workloads
 
-Bacalhau executes jobs by running them within containers. This section describes how to migrate a workload based on a Docker container into a format that will work with the Bacalhau client.
+Bacalhau executes jobs by running them within containers. Bacalhau employs a syntax closely resembling Docker, allowing you to utilize the same containers. The key distinction lies in how input and output data are transmitted to the container via IPFS, enabling scalability on a global level.
 
-:::tip
+This section describes how to migrate a workload based on a Docker container into a format that will work with the Bacalhau client.
 
-You can check out this example tutorial on [how to work with custom containers in Bacalhau](https://docs.bacalhau.org/examples/workload-onboarding/custom-containers/) to see how we used all these steps together.
+:::info
+
+You can check out this example tutorial on [how to work with custom containers in Bacalhau](../setting-up/workload-onboarding/custom-containers/index.md) to see how we used all these steps together.
 
 :::
 
 ## Requirements
-Here are a few things to note before getting started:
-* You must publish the container to a public container registry that is accessible from the Bacalhau network
-* Bacalhau supports only images that match the architecture of the host node. Typically, most nodes run `linux/amd64` so containers in `arm64` format are not able to run.
-* The `--input ipfs://...` flag does not support CID subpaths only **directories**
-* The `--input https://...` flag does not support URL directories only **single files** only
-* The `--input s3://...` flag does support S3 keys and prefixes. e.g. `s3://bucket/logs-2023-04*` for all April 2023 logs
+Here are few things to note before getting started:
+
+1. **Container Registry**: Ensure that the container is published to a public container registry that is accessible from the Bacalhau network.
+2. **Architecture Compatibility**: Bacalhau supports only images that match the host node's architecture. Typically, most nodes run on `linux/amd64`, so containers in `arm64` format are not able to run.
+3. **Input Flags**:  
+The `--input ipfs://...` flag supports only **directories** and does not support CID subpaths.  
+The `--input https://...` flag supports only **single files** and does not support URL directories.  
+The `--input s3://...` flag supports S3 keys and prefixes. For example, `s3://bucket/logs-2023-04*` includes all logs for April 2023.
 
-:::tip
+
+:::info
 
 You can check to see a [list of example public containers](https://github.com/orgs/bacalhau-project/packages?repo_name=examples) used by the Bacalhau team
 
@@ -35,8 +40,27 @@ You can check to see a [list of example public containers](https://github.com/or
 
 To help provide a safe, secure network for all users, we add the following runtime restrictions:
 
-- All ingress/egress networking is limited, as described in the [networking](../next-steps/networking.md) documentation. You won't be able to pull `data/code/weights/` etc from an external source
-- Data passing is implemented with Docker volumes, using [Bacalhau's input/output volumes](https://docs.bacalhau.org/about-bacalhau/architecture#input--output-volumes)
+1. **Limited Ingress/Egress Networking**:
+
+All ingress/egress networking is limited as described in the [networking](../setting-up/networking-instructions/fundamentals.md) documentation.
+You won't be able to pull `data/code/weights/` etc. from an external source.
+
+2. **Data Passing with Docker Volumes**:
+
+A job includes the concept of input and output volumes, and the Docker executor implements support for these. This means you can specify your CIDs, URLs, and/or S3 objects as `input` paths and also write results to an `output` volume. This can be seen in the following example:
+
+```shell
+bacalhau docker run \
+  -i s3://mybucket/logs-2023-04*:/input \
+  -o apples:/output_folder \
+  ubuntu \
+  bash -c 'ls /input > /output_folder/file.txt'
+```
+The above example demonstrates an input volume flag `-i s3://mybucket/logs-2023-04*`, which mounts all S3 objects in bucket `mybucket` with `logs-2023-04` prefix within the docker container at location `/input` (root).
+
+Output volumes are mounted to the Docker container at the location specified. In the example above, any content written to `/output_folder` will be made available within the `apples` folder in the job results CID.
+
+Once the job has run on the executor, the contents of `stdout` and `stderr` will be added to any named output volumes the job has used (in this case `apples`), and all those entities will be packaged into the results folder which is then published to a remote location by the publisher.
 
 
 ## Onboarding Your Workload
@@ -47,9 +71,9 @@ If you need to pass data into your container you will do this through a Docker v
 
 We make the assumption that you are reading from a directory called `/inputs`, which is set as the default.
 
-:::tip
+:::info
 
-You can specify which directory the data is written to with the [`--input`](https://docs.bacalhau.org/all-flags#run-python) CLI flag.
+You can specify which directory the data is written to with the [`--input`](../dev/cli-reference/all-flags.md#docker-run) CLI flag.
 
 :::
 
@@ -59,15 +83,15 @@ If you need to return data from your container you will do this through a Docker
 
 We make the assumption that you are writing to a directory called `/outputs`, which is set as the default.
 
-:::tip
+:::info
 
-You can specify which directory the data is written to with the [`--output-volumes`](https://docs.bacalhau.org/all-flags#run-python) CLI flag.
+You can specify which directory the data is written to with the [`--output-volumes`](../dev/cli-reference/all-flags.md#docker-run) CLI flag.
 
 :::
 
 ### Step 3 - Build and Push Your Image To a Registry
 
-If you haven't already, you'll need to [build your image](https://docs.docker.com/engine/reference/commandline/build/) and [push it](https://docs.docker.com/engine/reference/commandline/push/) to a publicly accessible container registry.
+At this step, you create (or update) a Docker image that Bacalhau will use to perform your task. You [build your image](https://docs.docker.com/engine/reference/commandline/build/) from your code and dependencies, then [push it](https://docs.docker.com/engine/reference/commandline/push/) to a public registry so that Bacalhau can access it. This is necessary for other Bacalhau nodes to run your container and execute the task.
 
 :::caution
 
@@ -83,6 +107,7 @@ $ docker build -t ${IMAGE} .
 $ docker image push ${IMAGE}
 ```
 
+
 ### Step 4 - Test Your Container
 
 To test your docker image locally, you'll need to execute the following command, changing the environment variables as necessary:
@@ -97,17 +122,34 @@ $ docker run --rm \
   ${IMAGE} \
   ${CMD}
 ```
+Let's see what each command will be used for:
+
+```shell
+$ export LOCAL_INPUT_DIR=$PWD
+Exports the current working directory of the host system to the LOCAL_INPUT_DIR variable. This variable will be used for binding a volume and transferring data into the container.
+
+$ export LOCAL_OUTPUT_DIR=$PWD
+Exports the current working directory of the host system to the LOCAL_OUTPUT_DIR variable. Similarly, this variable will be used for binding a volume and transferring data from the container.
+
+$ export CMD=(sh -c 'ls /inputs; echo do something useful > /outputs/stdout')
+Creates an array of commands CMD that will be executed inside the container. In this case, it is a simple command executing 'ls' in the /inputs directory and writing text to the /outputs/stdout file.
+
+$ docker run ... ${IMAGE} ${CMD}
+Launches a Docker container using the specified variables and commands. It binds volumes to facilitate data exchange between the host and the container.
+```
 
-:::tip
+:::info
 
-Bacalhau will use the [default ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint)
-if your image contains one. To override it, pass `--entrypoint` to `bacalhau docker run`.
+Bacalhau will use the [default ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint) if your image contains one. If you need to specify another entrypoint, use the `--entrypoint` flag to `bacalhau docker run`.
 
 :::
 
 For example:
 
 ```shell
+$ export LOCAL_INPUT_DIR=$PWD
+$ export LOCAL_OUTPUT_DIR=$PWD
+$ export CMD=(sh -c 'ls /inputs; echo "do something useful" > /outputs/stdout')
 $ export IMAGE=ubuntu
 $ docker run --rm \
   -v ${LOCAL_INPUT_DIR}:/inputs  \
@@ -117,10 +159,9 @@ $ docker run --rm \
 $ cat stdout
 ```
 
-This snippet results in:
+The result of the commands' execution is shown below:
 
-```
-...file listing...
+```shell
 do something useful
 ```
 
@@ -128,9 +169,9 @@ do something useful
 
 Data is identified by its content identifier (CID) and can be accessed by anyone who knows the CID. You can use either of these methods to upload your data:
 
-- [Copy data from a URL to public storage](https://docs.bacalhau.org/data-ingestion/from-url)
-- [Pin Data to public storage](https://docs.bacalhau.org/data-ingestion/pin)
-- [Copy Data from S3 Bucket to public storage](https://docs.bacalhau.org/data-ingestion/s3)
+[Copy data from a URL to public storage](../setting-up/data-ingestion/from-url.md)  
+[Pin Data to public storage](../setting-up/data-ingestion/pin.md)  
+[Copy Data from S3 Bucket to public storage](../setting-up/data-ingestion/s3.md)  
 
 :::info
 You can mount your data anywhere on your machine, and Bacalhau will be able to run against that data
@@ -138,23 +179,25 @@ You can mount your data anywhere on your machine, and Bacalhau will be able to r
 
 ### Step 6 - Run the Workload on Bacalhau
 
-To run your workload, run the following command:
+To launch your workload in a Docker container, using the specified image and working with `input` data specified via IPFS CID, run the following command:
 
 ```shell
 $ bacalhau docker run --input ipfs://${CID} ${IMAGE} ${CMD}
 ```
+
 To check the status of your job, run the following command:
 
 ```shell
-$ bacalhau list 
+$ bacalhau list --id-filter JOB_ID
 ```
-To get more information on your job
+
+To get more information on your job,run:
 
 ```shell
 $ bacalhau describe JOB_ID
 ```
 
-To download your job
+To download your job, run:
 
 ```shell
 $ bacalhau get JOB_ID
@@ -163,18 +206,19 @@ $ bacalhau get JOB_ID
 For example, running:
 
 ```shell
-$ job_id=$(bacalhau docker run ubuntu echo hello)
-$ bacalhau list --id-filter $job_id
-$ sleep 5
-$ bacalhau list --id-filter $job_id
-$ bacalhau get $job_id
-$ ls shards
+JOB_ID=$(bacalhau docker run ubuntu echo hello | grep 'Job ID:' | sed 's/.*Job ID: \([^ ]*\).*/\1/')
+echo "The job ID is: $JOB_ID"
+bacalhau list --id-filter $JOB_ID
+sleep 5
+bacalhau list --id-filter $JOB_ID
+bacalhau get $JOB_ID
+ls shards
 ```
 
 outputs:
 
-```
- CREATED   ID        JOB                      STATE      VERIFIED  PUBLISHED 
+```shell
+CREATED   ID        JOB                      STATE      VERIFIED  PUBLISHED 
  10:26:00  24440f0d  Docker ubuntu echo h...  Verifying                      
  CREATED   ID        JOB                      STATE      VERIFIED  PUBLISHED               
  10:26:00  24440f0d  Docker ubuntu echo h...  Published            /ipfs/bafybeiflj3kha... 
@@ -220,4 +264,5 @@ This can often be resolved by re-tagging your docker image
 
 ## Support
 
-If have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bit.ly/bacalhau-project-slack/archives/C02RLM3JHUY)(#bacalhau channel)
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
+
diff --git a/docs/docs/getting-started/index.md b/docs/docs/getting-started/index.md
index 9cf0788eff..b1a62f009b 100644
--- a/docs/docs/getting-started/index.md
+++ b/docs/docs/getting-started/index.md
@@ -1,4 +1,4 @@
 ---
-sidebar_label: "Getting Started"
-sidebar_position: 1
+sidebar_label: "Quick Start"
+sidebar_position: 2
 ---
\ No newline at end of file
diff --git a/docs/docs/getting-started/installation.md b/docs/docs/getting-started/installation.md
index 9befbeec9f..bd655828f7 100644
--- a/docs/docs/getting-started/installation.md
+++ b/docs/docs/getting-started/installation.md
@@ -1,92 +1,95 @@
 ---
 sidebar_label: 'Installation'
-sidebar_position: 2
+sidebar_position: 0
 ---
 
-# Getting Started with Bacalhau
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Installation
 
 In this tutorial, you'll learn how to install and run a job with the Bacalhau client using the Bacalhau CLI or Docker.
 
-## The Bacalhau Client
+## Step 1 - Install the Bacalhau Client
 
 The Bacalhau client is a command-line interface (CLI) that allows you to submit jobs to the Bacalhau.  The Bacalhau client is available for Linux, macOS, and Windows. You can also run the Bacalhau client in a Docker container.
 
-:::tip
-By default, you will submit to the Bacalhau public network, but the same CLI can be configured to submit to a private Bacalhau network. For more information, please read Running [Bacalhau on a Private Network](../next-steps/private-cluster).
-:::
-
-### Install the Bacalhau CLI
-
-You can install or update the Bacalhau CLI or pull a Docker image by running the commands in a terminal.
-You may need sudo mode or root password to install the local Bacalhau binary to `/usr/local/bin`:
-
-:::tip
-Using the **CLI**: Windows users can download the [latest release tarball from Github](https://github.com/bacalhau-project/bacalhau/releases) and extract `bacalhau.exe` to anywhere on the PATH.
-:::
-
 :::info
-To run a specific version of Bacalhau using Docker, use the command docker run -it ghcr.io/bacalhau-project/bacalhau:v1.0.3, where "v1.0.3" is the version you want to run; note that the "latest" tag will not re-download the image if you have an older version. For more information on running the Docker image, check out the [Bacalhau docker image example](../examples/workload-onboarding/bacalhau-docker-image/index.md).
+By default, you will submit to the Bacalhau public network, but the same CLI can be configured to submit to a private Bacalhau network. For more information, please read Running [Bacalhau on a Private Network](../setting-up/networking-instructions/private-cluster).
 :::
 
+### Step 1.1 - Install the Bacalhau CLI
 
 
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
 <Tabs
-defaultValue="CLI"
+defaultValue="Linux/macOS(CLI)"
 values={[
-{label: 'CLI', value: 'CLI'},
+{label: 'Linux/macOS(CLI)', value: 'Linux/macOS(CLI)'},
+{label: 'Windows(CLI)', value: 'Windows(CLI)'},
 {label: 'Docker', value: 'Docker'},
 ]}>
-<TabItem value="CLI">
+<TabItem value="Linux/macOS(CLI)">
 
+    You can install or update the Bacalhau CLI by running the commands in a terminal. You may need sudo mode or root password to install the local Bacalhau binary to `/usr/local/bin`:
+    ```shell
     curl -sL https://get.bacalhau.org/install.sh | bash
+    ```
+
+</TabItem>
+<TabItem value="Windows(CLI)">
+
+    Windows users can download the [latest release tarball from Github](https://github.com/bacalhau-project/bacalhau/releases) and extract `bacalhau.exe` to any location available in the PATH environment variable.
 
 </TabItem>
 <TabItem value="Docker">
 
+    ```shell
     docker image rm -f ghcr.io/bacalhau-project/bacalhau:latest # Remove old image if it exists
     docker pull ghcr.io/bacalhau-project/bacalhau:latest
-
+    ```
+    
+    To run a specific version of Bacalhau using Docker, use the command docker run -it ghcr.io/bacalhau-project/bacalhau:v1.0.3, where "v1.0.3" is the version you want to run; note that the "latest" tag will not re-download the image if you have an older version. For more information on running the Docker image, check out the [Bacalhau docker image example](../setting-up/workload-onboarding/bacalhau-docker-image/index.md).
 </TabItem>
 </Tabs>
 
-### Verify the Installation
-
-To run and Bacalhau client command with Docker, prefix it with `docker run ghcr.io/bacalhau-project/bacalhau:latest`.
 
-To verify installation and check the version of the client and server, use the `version` command, you can run the command:
+### Step 1.2 - Verify the Installation
 
+To verify installation and check the version of the client and server, use the `version` command.
+To run a Bacalhau client command with Docker, prefix it with `docker run ghcr.io/bacalhau-project/bacalhau:latest`.
 
 <Tabs
-defaultValue="CLI"
+defaultValue="Linux/macOS/Windows(CLI)"
 values={[
-{label: 'CLI', value: 'CLI'},
+{label: 'Linux/macOS/Windows(CLI)', value: 'Linux/macOS/Windows(CLI)'},
 {label: 'Docker', value: 'Docker'},
 ]}>
-<TabItem value="CLI">
+<TabItem value="Linux/macOS/Windows(CLI)">
 
+    ```shell
     bacalhau version
+    ```
 
 </TabItem>
 <TabItem value="Docker">
 
+    ```shell
     docker run -it ghcr.io/bacalhau-project/bacalhau:latest version
+    ```
 
 </TabItem>
 </Tabs>
 
-If you're wondering which server is being used, the Bacalhau Project has a [public Bacalhau server network](https://docs.bacalhau.org/#our-vision) that's shared with the community. This server allows you to launch your jobs from your computer without maintaining a compute cluster on your own.
+If you're wondering which server is being used, the Bacalhau Project has a [public Bacalhau server network](../setting-up/running-node/quick-start.md#ensure-your-storage-server-is-running) that's shared with the community. This server allows you to launch your jobs from your computer without maintaining a compute cluster on your own.
 
 
-## Let's submit a Hello World job
+## Step 2 - Submit a Hello World job
 
-To submit a job in Bacalhau, we will use the `bacalhau docker run` command. Let's take a quick look at its syntax:
+To submit a job in Bacalhau, we will use the `bacalhau docker run` command. The command runs a job using the Docker executor on the node. Let's take a quick look at its syntax:
 
-`bacalhau docker run [FLAGS] IMAGE[:TAG] [COMMAND]`
-
-The command below submits a Hello World job that runs an [echo](https://en.wikipedia.org/wiki/Echo_(command)) program within an [Ubuntu container](https://hub.docker.com/_/ubuntu):
+```shell
+bacalhau docker run [FLAGS] IMAGE[:TAG] [COMMAND]
+```
 
 <Tabs
 defaultValue="CLI"
@@ -96,99 +99,179 @@ values={[
 ]}>
 <TabItem value="CLI">
 
+    ```shell
     bacalhau docker run ubuntu echo Hello World
+    ```
 
-</TabItem>
-<TabItem value="Docker">
+    We will use the command to submit a Hello World job that runs an [echo](https://en.wikipedia.org/wiki/Echo_(command)) program within an [Ubuntu container](https://hub.docker.com/_/ubuntu).
 
-    docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
-    docker run \
-        --id-only \
-        --wait \
-        ubuntu:latest -- \
-            sh -c 'uname -a && echo "Hello from Docker Bacalhau!"'
+    Let's take a look at the results of the command execution in the terminal: 
 
-</TabItem>
-</Tabs>
+    ```shell
+    Job successfully submitted. Job ID: f8e7789d-8e76-4e6c-8e71-436e2d76c72e
+    Checking job status... (Enter Ctrl+C to exit at any time, your job will continue running):
 
-:::info
-While this command is designed to resemble Docker's run command which you may be familiar with, Bacalhau introduces a whole new set of [flags (see CLI Reference)](https://docs.bacalhau.org/all-flags#docker-run) to support its computing model.
-:::
+        Communicating with the network  ................  done ✅  0.2s
+           Creating job for submission  ................  done ✅  0.7s
+                       Job in progress  ................  done ✅  2.1s
+
+    To download the results, execute:
+        bacalhau get f8e7789d-8e76-4e6c-8e71-436e2d76c72e
+
+    To get more details about the run, execute:
+        bacalhau describe f8e7789d-8e76-4e6c-8e71-436e2d76c72e
+    ```
 
 After the above command is run, the job is submitted to the public network, which processes the job and Bacalhau prints out the related job id:
 
 ```
-Job successfully submitted. Job ID: 3b39baee-5714-4f17-aa71-1f5824665ad6
+Job successfully submitted. Job ID: 9d20bbad-c3fc-48f8-907b-1da61c927fbd
 Checking job status...
 ```
 
-The `job_id` above is shown in its full form. For convenience, you can use the shortened version, in this case: `3b39baee`. 
+The `job_id` above is shown in its full form. For convenience, you can use the shortened version, in this case: `9d20bbad`. 
 
-## Checking the State of your Jobs
+:::info
+While this command is designed to resemble Docker's run command which you may be familiar with, Bacalhau introduces a whole new set of [flags](../dev/cli-reference/all-flags.md#docker-run) to support its computing model.
+:::
 
-- **Job status**: You can check the status of the job using `bacalhau list`.
+</TabItem>
+<TabItem value="Docker">
+```shell
+docker run -t ghcr.io/bacalhau-project/bacalhau:latest \ 
+                docker run \  
+                --id-only \  
+                --wait \  
+                ubuntu:latest -- \ 
+                sh -c 'uname -a && echo "Hello from Docker Bacalhau!"'
+```
 
+Let's take a look at the results of the command execution in the terminal:
 
 ```shell
-bacalhau list --id-filter 3b39baee
+14:02:25.992 | INF pkg/repo/fs.go:81 > Initializing repo at '/root/.bacalhau' for environment 'production'
+19b105c9-4cb5-43bd-a12f-d715d738addd
 ```
 
-When it says `Completed`, that means the job is done, and we can get the results.
+</TabItem>
+</Tabs>
+
+
+## Step 3 - Checking the State of your Jobs
+After having deployed the job, we now can use the CLI for the interaction with the network. The jobs were sent to the public demo network, where it was processed and we can call the following functions. The `job_id` will differ for every submission.
+### Step 3.1 - Job status: 
 
+You can check the status of the job using `bacalhau list` command adding the `--id-filter` flag and specifying your job id.
+
+
+```shell
+bacalhau list --id-filter 9d20bbad
 ```
- CREATED   ID        JOB                      STATE      VERIFIED  COMPLETED
- 07:20:32  3b39baee  Docker ubuntu echo H...  Published            /ipfs/bafybeidu4zm6w...
+Let's take a look at the results of the command execution in the terminal: 
+
+```shell
+CREATED   ID          JOB                                       STATE      PUBLISHED 
+15:24:31  0ed7617d    Type:"docker",Params:"map[Entrypoint:<ni  Completed            
+                       l> EnvironmentVariables:[] Image:ubuntu:                       
+                       latest Parameters:[sh -c uname -a && ech                       
+                       o "Hello from Docker Bacalhau!"] Working                       
+                       Directory:]"                                                   
 ```
 
+When it says `Completed`, that means the job is done, and we can get the results.
+
 :::info
-For a comprehensive list of flags you can pass to the list command check out [the related CLI Reference page](../all-flags#list).
+For a comprehensive list of flags you can pass to the list command check out [the related CLI Reference page](../dev/cli-reference/all-flags.md#list-2).
 :::
 
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
+### Step 3.2 - Job information: 
+
+You can find out more information about your job by using `bacalhau describe`.
+
+```shell
+bacalhau describe 9d20bbad
+```
+Let's take a look at the results of the command execution in the terminal: 
 
 ```shell
-bacalhau describe 3b39baee
+
+    Job:
+        APIVersion: V1beta2
+        Metadata:
+            ClientID: 0ff57b2521334a92e9ddab4b2f8202c887b1eaa35d2aa945ab0e247d3bc0aa88
+            CreatedAt: "2023-12-21T15:24:31.750306239Z"
+            ID: 0ed7617d-d5ff-40f7-8411-89830b3f3058
+            Requester:
+            RequesterNodeID: QmbxGSsM6saCTyKkiWSxhJCt6Fgj7M9cns1vzYtfDbB5Ws
+            RequesterPublicKey: CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDEHTUAD1JzO0130W9vsaDGhU0PVgpcNjG3fYlE0sJ1BiBWENFuP4jx3Q9alcjNGhdRFdju0Mb/fidTOtJcPhxTdb+H6JxFP6HsADGes9jU4ylBU2SL2vfdb0KXzKdXjNHGGf4BuCGTcH07Oqxp209diK/cT7takL2fLjcgs1tM+6PzlfGzFqCPxvh9Sa0ek34mdmHjcp1XH8yjF1OKOuHvD+pYphqvOBL/2LEN+EBC4fz/QUnhUajCmKYO83MJcNUXSGxb4AN6K3DpVV+cJph7fj9ADdP7i996o2S4Gkz8W4Wpt/jICaPpkUjmyU3Jgcw7MHkZaYEzWxnnO2J936+pAgMBAAE=
+        Spec:
+        ...
+
 ```
 
 This outputs all information about the job, including stdout, stderr, where the job was scheduled, and so on.
 
-- **Job download**: You can download your job results directly by using `bacalhau get`. In the command below, we created a directory called `myfolder` and download our job output to be stored in that directory.
+### Step 3.3 - Job download: 
+
+You can download your job results directly by using `bacalhau get`. 
+
+
+```shell
+bacalhau get 9d20bbad
+```
+This results in 
+
+```shell
+Fetching results of job '0ed7617d'...
+Results for job '0ed7617d' have been written to...
+/Users/test/job-0ed7617d
+```
 
+In the command below, we created a directory called `myfolder` and download our job output to be stored in that directory.
 
 ```shell
-bacalhau get 3b39baee
+Fetching results of job '0ed7617d'...
+Results for job '0ed7617d' have been written to...
+/myfolder
 ```
 
+:::info
+While executing this command, you may encounter warnings regarding receive and send buffer sizes: `failed to sufficiently increase receive buffer size`. These warnings can arise due to limitations in the UDP buffer used by Bacalhau to process tasks. Additional information can be found in [https://github.com/quic-go/quic-go/wiki/UDP-Buffer-Sizes](https://github.com/quic-go/quic-go/wiki/UDP-Buffer-Sizes). 
+:::
+
 After the download has finished you should see the following contents in the results directory.
 
 ```shell
-$ tree job-3b39baee
-job-3b39baee
+job-0ed7617d
 ├── exitCode
 ├── outputs
 ├── stderr
 └── stdout
 ```
 
-## Viewing your Job Output
+## Step 4 - Viewing your Job Output
 
 ```shell
-$ cat job-3b39baee/stdout
+$ cat job-9d20bbad/stdout
 ```
 
 That should print out the string `Hello World`.
 
-With that, you have just successfully run a job on the Bacalhau network! :fish:
+```shell
+Hello world
+```
+
+With that, you have just successfully run a job on Bacalhau! :fish:
 
-## Where to go next?
+## Step 5 - Where to go next?
 
-Here are a few resources that provide a deeper dive into running jobs with Bacalhau:
+Here are few resources that provide a deeper dive into running jobs with Bacalhau:
 
-* [How to run an existing workload on Bacalhau](../getting-started/docker-workload-onboarding.md)
-* [Walk through a more data intensive demo](../examples/data-engineering/image-processing/index.md)
-* [Check out the Bacalhau CLI Reference page](../all-flags.md)
+ [How Bacalhau works](../getting-started/architecture.md)  
+ [Setting up Bacalhau](../setting-up)  
+ [Examples & Use Cases](../examples)  
 
 
-## Need Support?
+## Support
 
-If have questions or need support or guidance, please reach out to the [Bacalhau team via Slack (#bacalhau channel)](https://bit.ly/bacalhau-project-slack)
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/getting-started/resources.md b/docs/docs/getting-started/resources.md
index f39e5a88b7..8e21125e6c 100644
--- a/docs/docs/getting-started/resources.md
+++ b/docs/docs/getting-started/resources.md
@@ -1,13 +1,15 @@
 ---
-sidebar_label: 'Specifying Hardware Requirements'
-sidebar_position: 20
+sidebar_label: 'Hardware/GPU setup'
+sidebar_position: 4
 ---
 
-# Specifying Hardware Requirements
+# Hardware Setup
 
-Not all jobs are created equal. Some jobs require more resources than others or have specific hardware requirements like GPUs. This page describes how to specify hardware requirements for your job.
+Different jobs may require different amounts of resources to execute. Some jobs may have specific hardware requirements, such as GPU. This page describes how to specify hardware requirements for your job.
 
+:::info
 Please bear in mind that each executor is implemented independently and these docs might be slightly out of date. Double check the man page for the executor you are using with `bacalhau [executor] --help`.
+:::
 
 ## Docker Executor
 
@@ -16,23 +18,58 @@ The following table describes how to specify hardware requirements for the Docke
 
 Flag | Default | Description
 ---------|----------|---------
- `--cpu` | 0.1 ([source](https://github.com/bacalhau-project/bacalhau/blob/main/pkg/capacitymanager/capacitymanager.go#L9)) | Job CPU cores (e.g. 500m, 2, 8)
- `--memory` | 100MB ([source](https://github.com/bacalhau-project/bacalhau/blob/main/pkg/capacitymanager/capacitymanager.go#L10)) | Job Memory requirement (e.g. 500Mb, 2Gb, 8Gb).
- `--gpu` | 0 ([source](https://github.com/bacalhau-project/bacalhau/blob/main/pkg/capacitymanager/capacitymanager.go#L11)) | Job GPU requirement (e.g. 1).
+ `--cpu` | 0.1 ([source](/)) | Job CPU cores (e.g. 500m, 2, 8)
+ `--memory` | 100MB ([source](/)) | Job Memory requirement (e.g. 500Mb, 2Gb, 8Gb).
+ `--gpu` | 0 ([source](/)) | Job GPU requirement (e.g. 1).
+
+## WASM Executor
+
+**TBD - research required**
 
 ### How it Works
 
 When you specify hardware requirements, the job will be offered out to the network to see if there are any nodes that can satisfy the requirements. If there are, the job will be scheduled on the node and the executor will be started.
 
-If there are no nodes that can satisfy the requirements, the job will wait for a node to become available, until it times out [after 3 minutes](https://github.com/bacalhau-project/bacalhau/blob/main/pkg/computenode/config.go#L12).
+
+**TBD - research required:** If there are no nodes that can satisfy the requirements, the job will wait for a node to become available, until it times out [after 3 minutes](/).
+
+
+
+
+## GPU Setup
+
+Bacalhau supports GPU workloads. Learn how to run a job using GPU workloads with the Bacalhau client.
+
+### Prerequisites
+
+* The Bacalhau network must have an executor node with a GPU exposed
+* Your container must include the CUDA runtime (cudart) and must be compatible with the CUDA version running on the node
+
+## Usage
+
+Use following command to see available resources amount:
+
+```bash
+bacalhau node list --show=capacity
+```
+
+To submit a request for a job that requires more than the standard set of resources, add the `--cpu` and `--memory` flags. For example, for a job that requires 2 CPU cores and 4Gb of RAM, use `--cpu=2 --memory=4Gb`, e.g.:
+
+```bash
+bacalhau docker run ubuntu echo Hello World --cpu=2 --memory=4Gb
+```
+
+To submit a GPU job request, use the `--gpu` flag under the `docker run` command to select the number of GPUs your job requires. For example:
+
+```bash
+bacalhau docker run --gpu=1 nvidia/cuda:11.0.3-base-ubuntu20.04 nvidia-smi
+```
 
 ### Limitations
 
 The following limitations currently exist within Bacalhau.
 
 * Maximum CPU and memory limits depend on the participants in the network
-* See [the dedicated page](docs/next-steps/gpu.md) on GPUs to see GPU limitations
-
-### Also See
-
-* [GPU workload tutorial](docs/next-steps/gpu.md)
+* For GPU:
+    * NVIDIA, Intel or AMD GPUs only
+    * Only the Docker Executor supports GPUs
\ No newline at end of file
diff --git a/docs/docs/getting-started/wasm-workload-onboarding.md b/docs/docs/getting-started/wasm-workload-onboarding.md
index a0c9cc5951..ed4c860026 100644
--- a/docs/docs/getting-started/wasm-workload-onboarding.md
+++ b/docs/docs/getting-started/wasm-workload-onboarding.md
@@ -1,46 +1,57 @@
 ---
-sidebar_label: 'Onboard WebAssembly Workload'
-sidebar_position: 3
+sidebar_label: 'Workloads (WebAssembly)'
+sidebar_position: 4
 ---
-# Onboarding Your WebAssembly Workloads
+# WebAssembly (WASM) Workloads
 
 Bacalhau supports running programs that are compiled to [WebAssembly (WASM)](https://webassembly.org/). With the Bacalhau client, you can upload WASM programs, retrieve data from public storage, read and write data, receive program arguments, and access environment variables.
 
 ## Prerequisites and Limitations
 
+1. **Supported WebAssembly System Interface (WASI)**  
 Bacalhau can run compiled WASM programs that expect the WebAssembly System Interface (WASI) Snapshot 1. Through this interface, WebAssembly programs can access data, environment variables, and program arguments.
 
-All ingress/egress networking is disabled – you won't be able to pull data/code/weights/etc from an external source. WASM jobs can say what data they need using URLs or CIDs (Content IDentifier) and can then access the data by reading from the filesystem.
+2. **Networking Restrictions**  
+All ingress/egress networking is disabled – you won't be able to pull `data/code/weights` etc. from an external source. WASM jobs can say what data they need using URLs or CIDs (Content IDentifier) and can then access the data by reading from the filesystem.
 
+3. **Single-Threading**  
 There is no multi-threading as WASI does not expose any interface for it.
 
-## Onboarding
+
+## Onboarding Your Workload
 
 ### Step 1: Replace network operations with filesystem reads and writes
 
-If your program would normally read and write to network endpoints, you'll need to replace this with filesystem operations.
+If your program typically involves reading from and writing to network endpoints, follow these steps to adapt it for Bacalhau:
+
+1. **Replace Network Operations:**  
+Instead of making HTTP requests to external servers (e.g., example.com), modify your program to read data from the local filesystem.
 
-For example, instead of making an HTTP request to `example.com`, instead read from the `/inputs` folder. You can then specify the URL to Bacalhau when you run the job using `--input http://example.com`.
+2. **Input Data Handling:**
+Specify the input data location in Bacalhau using the `--input` flag when running the job. For instance, if your program used to fetch data from `example.com`, read from the `/inputs` folder locally, and provide the URL as input when executing the Bacalhau job. For example, `--input http://example.com`.  
 
-You can write results to standard out or standard error pipes or to the filesystem into an output mount. For example, WASM jobs by default will have access to a folder at `/outputs` that will be persisted when the job ends.
+3. **Output Handling:**
+Adjust your program to output results to standard output (`stdout`) or standard error (`stderr`) pipes. Alternatively, you can write results to the filesystem, typically into an output mount. In the case of WASM jobs, a default folder at `/outputs` is available, ensuring that data written there will persist after the job concludes.
 
-:::tip
-You can specify more or different output mounts using the `-o` flag.
+By making these adjustments, you can effectively transition your program to operate within the Bacalhau environment, utilizing filesystem operations instead of traditional network interactions.
+
+:::info
+You can specify additional or different output mounts using the `-o` flag.
 :::
 
 ### Step 2: Configure your compiler to output WASI-compliant WebAssembly
 
 You will need to compile your program to WebAssembly that expects WASI. Check the instructions for your compiler to see how to do this.
 
-For example, Rust users can specify the `wasm32-wasi` target to `rustup` and `cargo` to get programs compiled for WASI WebAssembly. See [the Rust example](../examples/workload-onboarding/rust-wasm/index.md) for more information on this.
+For example, Rust users can specify the `wasm32-wasi` target to `rustup` and `cargo` to get programs compiled for WASI WebAssembly. See [the Rust example](../setting-up/workload-onboarding/rust-wasm/index.md) for more information on this.
 
 ### Step 3: Upload the input data
 
 Data is identified by its content identifier (CID) and can be accessed by anyone who knows the CID. You can use either of these methods to upload your data:
 
-- [Copy data from a URL to public storage](https://docs.bacalhau.org/examples/data-ingestion/from-url/)
-- [Pin Data to public storage](https://docs.bacalhau.org/examples/data-ingestion/pinning/)
-- [Copy Data from S3 Bucket to public storage](https://docs.bacalhau.org/examples/data-ingestion/s3-to-ipfs/)
+ [Copy data from a URL to public storage](../setting-up/data-ingestion/from-url.md)  
+ [Pin Data to public storage](../setting-up/data-ingestion/pin.md)  
+ [Copy Data from S3 Bucket to public storage](../setting-up/data-ingestion/s3.md)
 
 :::info
 You can mount your data anywhere on your machine, and Bacalhau will be able to run against that data
@@ -48,29 +59,61 @@ You can mount your data anywhere on your machine, and Bacalhau will be able to r
 
 ### Step 4: Run your program
 
-You can run a WebAssembly program on Bacalhau using the `bacalhau wasm run` command.
+You can run a WebAssembly program on Bacalhau using the `bacalhau wasm run` command. 
+
+```shell
+$ bacalhau wasm run
+```
+
+**Run Locally Compiled Program:**
+
+If your program is locally compiled, specify it as an argument. For instance, running the following command will upload and execute the `main.wasm` program:
+
+```shell
+$ bacalhau wasm run main.wasm
+```
 
-To run a locally compiled WASM program, specify it as an argument. For example, running `bacalhau wasm run main.wasm` will upload and execute the `main.wasm` program.
 
 :::caution
 The program you specify will be uploaded to a Bacalhau storage node and will be publicly available.
 :::
 
-Alternatively, you can specify a WASM program by
-using a CID, like `bacalhau wasm run Qmajb9T3jBdMSp7xh2JruNrqg3hniCnM6EUVsBocARPJRQ`.
+
+**Alternative Program Specification:**
+
+ You can use a Content IDentifier (CID) for a specific WebAssembly program.
+
+
+```shell
+$ bacalhau wasm run Qmajb9T3jBdMSp7xh2JruNrqg3hniCnM6EUVsBocARPJRQ
+```
+
+**Input Data Specification:**
 
 Make sure to specify any input data using `--input` flag.
 
+```shell
+$ bacalhau wasm run --input http://example.com
+```
+This ensures the necessary data is available for the program's execution.
+
 
 #### Program arguments
 
-You can give the WASM program arguments by specifying them after the program path or CID.
+You can give the WASM program arguments by specifying them after the program path or CID. If the WASM program is already compiled and located in the current directory, you can run it by adding arguments after the file name:
 
 ```shell
 $ bacalhau wasm run echo.wasm hello world
 ```
 
-:::tip
+For a specific WebAssembly program, run:
+
+```shell
+$ bacalhau wasm run Qmajb9T3jBdMSp7xh2JruNrqg3hniCnM6EUVsBocARPJRQ hello world
+```
+
+
+:::info
 
 Write your program to use program arguments to specify input and output paths. This makes your program more flexible in handling different configurations of input and output volumes.
 
@@ -93,9 +136,9 @@ $ bacalhau wasm run prog.wasm -e HELLO=world
 
 ## Examples
 
-See [the Rust example](../examples/workload-onboarding/rust-wasm/index.md) for a workload that leverages WebAssembly support.
+See [the Rust example](../setting-up/workload-onboarding/rust-wasm/index.md) for a workload that leverages WebAssembly support.
 
 ## Support
 
 
-If have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bit.ly/bacalhau-project-slack/archives/C02RLM3JHUY)(#bacalhau channel)
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
diff --git a/docs/docs/references/sdk/python-sdk.md b/docs/docs/integration/python-sdk.md
similarity index 100%
rename from docs/docs/references/sdk/python-sdk.md
rename to docs/docs/integration/python-sdk.md
diff --git a/docs/docs/integration/wasm-observe.md b/docs/docs/integration/wasm-observe.md
index 1409a1f389..8f966e6f7e 100644
--- a/docs/docs/integration/wasm-observe.md
+++ b/docs/docs/integration/wasm-observe.md
@@ -6,18 +6,18 @@ sidebar_position: 4
 # Observability for WebAssembly Workloads in Bacalhau
 
 Gain deeper insights into the WebAssembly (Wasm) jobs running on Bacalhau compute nodes using the 
-[Observe SDK](https://dev.dylibso.com/docs/category/observe-sdk/), an open-source library that unlocks modern observability for WebAssembly. This feature supplements the [host-level observability](/running-node/observability/) data with additional traces extracted from within the Wasm modules running on compute nodes in a Bacalhau network.
+[Observe SDK](https://dev.dylibso.com/docs/category/observe-sdk/), an open-source library that unlocks modern observability for WebAssembly. This feature supplements the [host-level observability](../setting-up/running-node/observability) data with additional traces extracted from within the Wasm modules running on compute nodes in a Bacalhau network.
 
 ## Features
 - Extract telemetry data from Wasm workloads. Currently supports tracing, with logs and metrics coming soon.
-- Data can be sent to the [same viewing destinations](/running-node/observability/#viewing) (ie. sinks) that are supported for the host-level data.
+- Data can be sent to the [same viewing destinations](../setting-up/running-node/observability#viewing) (ie. sinks) that are supported for the host-level data.
 - Utilizes the same Trace ID as the host-level data, allowing for seamless visibility into the end-to-end execution of the job.
 
 ## Installing the SDK
 
-- The Observe SDK is integrated with the default WebAssembly [Executor](/getting-started/architecture/#executor) provided by Bacalhau, so node operators are not required to integrate the SDK itself as long as a custom / pluggable Executor is not being used.
+- The Observe SDK is integrated with the default WebAssembly [Executor](../getting-started/architecture#executor) provided by Bacalhau, so node operators are not required to integrate the SDK itself as long as a custom / pluggable Executor is not being used.
 - *(Optional)* For node operators using a custom Executer see [here](https://dev.dylibso.com/docs/observe/adapters/golang/opentelemetry) for instructions on how to integrate the Observe SDK.
-- The SDK uses the same environment variables noted [here](/running-node/observability/#viewing) for sending data out to a viewing destination.
+- The SDK uses the same environment variables noted [here](../setting-up/running-node/observability#viewing) for sending data out to a viewing destination.
 
 ## Usage
 
diff --git a/docs/docs/intro.md b/docs/docs/intro.md
index 3a94b168ac..5af6491d57 100644
--- a/docs/docs/intro.md
+++ b/docs/docs/intro.md
@@ -1,6 +1,6 @@
 ---
-title: Home
-sidebar_label: 'Home'
+title: About Bacalhau
+sidebar_label: 'About Bacalhau'
 sidebar_position: 1
 slug: /
 hide_title: true
@@ -12,7 +12,7 @@ hide_title: true
 
 # What is Bacalhau?
 
-Bacalhau is a platform for fast, cost efficient, and secure computation by running jobs where the data is generated and stored. With Bacalhau, you can streamline your existing workflows without the need of extensive rewriting by running  arbitrary Docker containers and WebAssembly (wasm) images as tasks. This architecture is also referred to as **Compute Over Data** (or CoD). _[Bacalhau](https://translate.google.com/?sl=pt&tl=en&text=bacalhau&op=translate) was coined from the Portuguese word for salted Cod fish_.
+Bacalhau is a platform for fast, cost efficient, and secure computation by running jobs where the data is generated and stored. With Bacalhau, you can streamline your existing workflows without the need of extensive rewriting by running arbitrary Docker containers and WebAssembly (wasm) images as tasks. This architecture is also referred to as **Compute Over Data** (or CoD). _[Bacalhau](https://translate.google.com/?sl=pt&tl=en&text=bacalhau&op=translate) was coined from the Portuguese word for salted Cod fish_.
 
 Bacalhau seeks to transform data processing for large-scale datasets to improve cost and efficiency, and to open up data processing to larger audiences. Our goals is to create an open, collaborative compute ecosystem that enables unparalleled collaboration. We ([Expanso.io](https://expanso.io)) offer a demo network so you can try out jobs without even installing. Give it a shot!
 
@@ -34,45 +34,18 @@ Bacalhau seeks to transform data processing for large-scale datasets to improve
 
 📚 Bacalhau operates at scale over parallel jobs. You can batch process petabytes (quadrillion bytes) of data.
 
-## Quick Start ⏱️
-
-> Understand Bacalhau in 1 minute
-
-Install the bacalhau client:
-
-- Option 1: Official installer for Windows, Linux & Mac OS
-
-```bash
-curl -sL https://get.bacalhau.org/install.sh | bash
-```
-
-- Option 2: Install with Go 1.20
-
-```bash
-go install github.com/bacalhau-project/bacalhau@latest
-```
-
-Submit a "Hello World" job:
-
-```bash
-bacalhau docker run ubuntu echo Hello World
-```
+## How it works
 
-The job runs on the demo Bacalhau network.
+Bacalhau concists of a peer-to-peer network of nodes that enables decentralized communication between computers. The network consists of two types of nodes:  
 
-Download your result:
+  **Requester Node:** responsible for handling user requests, discovering and ranking compute nodes, forwarding jobs to compute nodes, and monitoring the job lifecycle.  
 
-```bash
-bacalhau get 63d08ff0..... # make sure to use the right job id from the docker run command
-```
+  **Compute Node:** responsible for executing jobs and producing results. Different compute nodes can be used for different types of jobs, depending on their capabilities and resources.
 
 :::info
 For a more detailed tutorial, check out our [Getting Started Tutorial](https://docs.bacalhau.org/getting-started/installation).
 :::
 
-
-## How it works
-
 The goal of the Bacalhau project is to make it easy to perform distributed computation next to where the data resides. In order to do this, first you need to ingest some data.
 
 ### Data ingestion
diff --git a/docs/docs/next-steps/_category_.yml b/docs/docs/next-steps/_category_.yml
deleted file mode 100644
index 448ce75165..0000000000
--- a/docs/docs/next-steps/_category_.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-label: "Processes"
-position: 5
diff --git a/docs/docs/references/api/_category_.yml b/docs/docs/references/api/_category_.yml
deleted file mode 100644
index 24a4602617..0000000000
--- a/docs/docs/references/api/_category_.yml
+++ /dev/null
@@ -1,1 +0,0 @@
-label: "API"
\ No newline at end of file
diff --git a/docs/docs/references/cli/_category_.yml b/docs/docs/references/cli/_category_.yml
deleted file mode 100644
index ee62c4020c..0000000000
--- a/docs/docs/references/cli/_category_.yml
+++ /dev/null
@@ -1,1 +0,0 @@
-label: "Commands (CLI)"
\ No newline at end of file
diff --git a/docs/docs/references/job-specification/_category_.yml b/docs/docs/references/job-specification/_category_.yml
deleted file mode 100644
index 225ee85e48..0000000000
--- a/docs/docs/references/job-specification/_category_.yml
+++ /dev/null
@@ -1,4 +0,0 @@
-label: "Job Specification"
-link:
-  type: doc
-  id: references/job-specification/job
\ No newline at end of file
diff --git a/docs/docs/references/sdk/_category_.yml b/docs/docs/references/sdk/_category_.yml
deleted file mode 100644
index ef87bffcc7..0000000000
--- a/docs/docs/references/sdk/_category_.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-label: "SDK"
-link:
-  type: 'generated-index'
diff --git a/docs/docs/setting-up/_category_.yml b/docs/docs/setting-up/_category_.yml
new file mode 100644
index 0000000000..8eb2f13361
--- /dev/null
+++ b/docs/docs/setting-up/_category_.yml
@@ -0,0 +1,2 @@
+label: "Setting Up Bacalhau"
+position: 3
diff --git a/docs/docs/setting-up/data-ingestion/_category_.yml b/docs/docs/setting-up/data-ingestion/_category_.yml
new file mode 100644
index 0000000000..95944eb815
--- /dev/null
+++ b/docs/docs/setting-up/data-ingestion/_category_.yml
@@ -0,0 +1,2 @@
+label: "Data Ingestions"
+position: 3
\ No newline at end of file
diff --git a/docs/docs/data-ingestion/from-url.md b/docs/docs/setting-up/data-ingestion/from-url.md
similarity index 100%
rename from docs/docs/data-ingestion/from-url.md
rename to docs/docs/setting-up/data-ingestion/from-url.md
diff --git a/docs/docs/setting-up/data-ingestion/index.md b/docs/docs/setting-up/data-ingestion/index.md
new file mode 100644
index 0000000000..40e7e39631
--- /dev/null
+++ b/docs/docs/setting-up/data-ingestion/index.md
@@ -0,0 +1,7 @@
+---
+sidebar_label: Data Ingestion"
+sidebar_position: 4
+---
+# Data ingestion with Bacalhau
+
+This directory contains instructions on how to setup the data ingestion in Bacalhau.
\ No newline at end of file
diff --git a/docs/docs/setting-up/data-ingestion/pin.md b/docs/docs/setting-up/data-ingestion/pin.md
new file mode 100644
index 0000000000..39e7df7080
--- /dev/null
+++ b/docs/docs/setting-up/data-ingestion/pin.md
@@ -0,0 +1,17 @@
+---
+sidebar_label: "Pinning data"
+sidebar_position: 2
+description: "How to pin data to public storage"
+---
+# Pinning Data
+
+If you have data that you want to make available to your Bacalhau jobs (or other people), you can pin it using a pinning service like Pinata, NFT.Storage, Thirdweb, etc. Pinning services store data on behalf of users. The pinning provider is essentially guaranteeing that your data will be available if someone knows the CID. Most pinning services offer you a free tier, so you can try them out without spending any money.
+
+
+## Basic steps
+
+To use a pinning service, you will almost always need to create an account. After registration, you get an API token, which is necessary to control and access the files. Then you need to upload files - usually services provide a web interface, CLI and code samples for integration into your application. Once you upload the files you will get its CID, which looks like this: `QmUyUg8en7G6RVL5uhyoLBxSWFgRMdMraCRWFcDdXKWEL9`. Now you can access pinned data from the jobs via this CID.
+
+:::info
+Data source can be specified via `--input` flag, see the [CLI Guide](../../dev/cli-reference/all-flags.md#docker-run) for more details
+:::
diff --git a/docs/docs/data-ingestion/s3.md b/docs/docs/setting-up/data-ingestion/s3.md
similarity index 100%
rename from docs/docs/data-ingestion/s3.md
rename to docs/docs/setting-up/data-ingestion/s3.md
diff --git a/docs/docs/next-steps/gpu.md b/docs/docs/setting-up/gpu.md
similarity index 93%
rename from docs/docs/next-steps/gpu.md
rename to docs/docs/setting-up/gpu.md
index 3771fee743..546d1d87e2 100644
--- a/docs/docs/next-steps/gpu.md
+++ b/docs/docs/setting-up/gpu.md
@@ -1,9 +1,9 @@
 ---
 sidebar_position: 3
-sidebar_label: 'GPU Workloads'
+sidebar_label: 'GPU Setup'
 ---
 
-# GPU Workloads
+# GPU Workloads Setup
 
 Bacalhau supports GPU workloads. In this tutorial, learn how to run a job using GPU workloads with the Bacalhau client.
 
diff --git a/docs/docs/setting-up/jobs/index.md b/docs/docs/setting-up/jobs/index.md
new file mode 100644
index 0000000000..e18a0e8c67
--- /dev/null
+++ b/docs/docs/setting-up/jobs/index.md
@@ -0,0 +1,8 @@
+---
+sidebar_label: "Job setup"
+sidebar_position: 2
+---
+# Networking with Bacalhau
+
+This directory contains instructions on how to setup the networking in Bacalhau.
+
diff --git a/docs/docs/setting-up/jobs/job-selection.md b/docs/docs/setting-up/jobs/job-selection.md
new file mode 100644
index 0000000000..729b6c64e4
--- /dev/null
+++ b/docs/docs/setting-up/jobs/job-selection.md
@@ -0,0 +1,92 @@
+---
+sidebar_label: 'Job Selection Policy'
+sidebar_position: 2
+---
+
+# Job selection policy
+
+When running a node, you can choose which jobs you want to run by using
+configuration options, environment variables or flags to specify a job selection
+policy.
+
+| Config property | `serve` flag | Default value | Meaning |
+|---|---|---|---|
+| Node.Compute.JobSelection.Locality | `--job-selection-data-locality` | Anywhere | Only accept jobs that reference data we have locally ("local") or anywhere ("anywhere"). |
+| Node.Compute.JobSelection.ProbeExec | `--job-selection-probe-exec` | unused | Use the result of an external program to decide if we should take on the job. |
+| Node.Compute.JobSelection.ProbeHttp | `--job-selection-probe-http` | unused | Use the result of a HTTP POST to decide if we should take on the job. |
+| Node.Compute.JobSelection.RejectStatelessJobs | `--job-selection-reject-stateless` | False | Reject jobs that don't specify any [input data](../data-ingestion/index.md). |
+| Node.Compute.JobSelection.AcceptNetworkedJobs | `--job-selection-accept-networked` | False | Accept jobs that require [network connections](../networking-instructions/networking.md). |
+
+setting-up/networking-instructions/networking.md
+
+## Job selection probes
+
+If you want more control over making the decision to take on jobs, you can use the `--job-selection-probe-exec` and `--job-selection-probe-http` flags.
+
+These are external programs that are passed the following data structure so that they can make a decision about whether or not to take on a job:
+
+```json
+{
+  "node_id": "XXX",
+  "job_id": "XXX",
+  "spec": {
+    "engine": "docker",
+    "verifier": "ipfs",
+    "job_spec_vm": {
+      "image": "ubuntu:latest",
+      "entrypoint": ["cat", "/file.txt"]
+    },
+    "inputs": [{
+      "engine": "ipfs",
+      "cid": "XXX",
+      "path": "/file.txt"
+    }]
+  }
+}
+```
+
+The `exec` probe is a script to run that will be given the job data on `stdin`, and must exit with status code 0 if the job should be run.
+
+The `http` probe is a URL to POST the job data to. The job will be rejected if
+the HTTP request returns a non-positive status code (e.g. >= 400).
+
+If the HTTP response is a JSON blob, it should match the [following
+schema](https://github.com/bacalhau-project/bacalhau/blob/885d53e93b01fb343294d7ddbdbffe89918db800/pkg/bidstrategy/type.go#L18-L22)
+and will be used to respond to the bid directly:
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "shouldBid": {
+      "description": "If the job should be accepted",
+      "type": "boolean"
+    },
+    "shouldWait": {
+      "description": "If the node should wait for an async response that will come later. `shouldBid` will be ignored",
+      "type": "boolean",
+      "default": false,
+    },
+    "reason": {
+      "description": "Human-readable string explaining why the job should be accepted or rejected, or why the wait is required",
+      "type": "string"
+    }
+  },
+  "required": [
+    "shouldBid",
+    "reason"
+  ]
+}
+```
+
+For example, the following response will reject the job:
+
+```json
+{
+  "shouldBid": false,
+  "reason": "The job did not pass this specific validation: ...",
+}
+```
+
+If the HTTP response is not a JSON blob, the content is ignored and any non-error status code will accept the job.
diff --git a/docs/docs/references/job-specification/constraint.md b/docs/docs/setting-up/jobs/job-specification/constraint.md
similarity index 100%
rename from docs/docs/references/job-specification/constraint.md
rename to docs/docs/setting-up/jobs/job-specification/constraint.md
diff --git a/docs/docs/setting-up/jobs/job-specification/index.md b/docs/docs/setting-up/jobs/job-specification/index.md
new file mode 100644
index 0000000000..958fdcaade
--- /dev/null
+++ b/docs/docs/setting-up/jobs/job-specification/index.md
@@ -0,0 +1,8 @@
+---
+sidebar_label: "Job specifications"
+sidebar_position: 0
+---
+# Job specifications
+
+This directory contains instructions on how to setup specifications for jobs in Bacalhau.
+
diff --git a/docs/docs/references/job-specification/input-source.md b/docs/docs/setting-up/jobs/job-specification/input-source.md
similarity index 100%
rename from docs/docs/references/job-specification/input-source.md
rename to docs/docs/setting-up/jobs/job-specification/input-source.md
diff --git a/docs/docs/references/job-specification/job.md b/docs/docs/setting-up/jobs/job-specification/job.md
similarity index 97%
rename from docs/docs/references/job-specification/job.md
rename to docs/docs/setting-up/jobs/job-specification/job.md
index df5dc2b2f0..dfbb137bb2 100644
--- a/docs/docs/references/job-specification/job.md
+++ b/docs/docs/setting-up/jobs/job-specification/job.md
@@ -30,7 +30,7 @@ Tasks:
 ## `job` Parameters
 - **Name** `(string : <optional>)`: A logical name to refer to the job. Defaults to job ID.
 - **Namespace** `(string: "default")`: The namespace in which the job is running. `ClientID` is used as a namespace in the public demo network.
-- **Type** `(string: <required>)`: The type of the job, such as `batch`, `ops`, `daemon` or `service`. You can learn more about the supported jobs types in the [Job Types](/topic-guides/job-types) guide.
+- **Type** `(string: <required>)`: The type of the job, such as `batch`, `ops`, `daemon` or `service`. You can learn more about the supported jobs types in the [Job Types](../job-types) guide.
 - **Priority** `(int: 0`): Determines the scheduling priority.
 - **Count** `(int: <required)`: Number of replicas to be scheduled. This is only applicable for jobs of type `batch` and `service`.
 - **Meta** <code>(<a href="./meta">Meta</a> : nil)</code>: Arbitrary metadata associated with the job.
diff --git a/docs/docs/references/job-specification/label.md b/docs/docs/setting-up/jobs/job-specification/label.md
similarity index 100%
rename from docs/docs/references/job-specification/label.md
rename to docs/docs/setting-up/jobs/job-specification/label.md
diff --git a/docs/docs/references/job-specification/meta.md b/docs/docs/setting-up/jobs/job-specification/meta.md
similarity index 100%
rename from docs/docs/references/job-specification/meta.md
rename to docs/docs/setting-up/jobs/job-specification/meta.md
diff --git a/docs/docs/references/job-specification/network.md b/docs/docs/setting-up/jobs/job-specification/network.md
similarity index 100%
rename from docs/docs/references/job-specification/network.md
rename to docs/docs/setting-up/jobs/job-specification/network.md
diff --git a/docs/docs/references/job-specification/resources.md b/docs/docs/setting-up/jobs/job-specification/resources.md
similarity index 100%
rename from docs/docs/references/job-specification/resources.md
rename to docs/docs/setting-up/jobs/job-specification/resources.md
diff --git a/docs/docs/references/job-specification/result-path.md b/docs/docs/setting-up/jobs/job-specification/result-path.md
similarity index 100%
rename from docs/docs/references/job-specification/result-path.md
rename to docs/docs/setting-up/jobs/job-specification/result-path.md
diff --git a/docs/docs/references/job-specification/spec-config.md b/docs/docs/setting-up/jobs/job-specification/spec-config.md
similarity index 87%
rename from docs/docs/references/job-specification/spec-config.md
rename to docs/docs/setting-up/jobs/job-specification/spec-config.md
index b45e698e3a..935636febf 100644
--- a/docs/docs/references/job-specification/spec-config.md
+++ b/docs/docs/setting-up/jobs/job-specification/spec-config.md
@@ -28,7 +28,7 @@ Here are a few hypothetical examples to demonstrate how you might define `SpecCo
   }
 }
 ```
-Full Docker spec can be found [here](../other-specifications/engines/docker).
+Full Docker spec can be found [here](../../other-specifications/engines/docker).
 
 ### S3 Publisher
 
@@ -41,7 +41,7 @@ Full Docker spec can be found [here](../other-specifications/engines/docker).
   }
 }
 ```
-Full S3 Publisher can be found [here](../other-specifications/publishers/s3).
+Full S3 Publisher can be found [here](../../other-specifications/publishers/s3).
 
 ### Local Directory Input Source
 
@@ -54,6 +54,6 @@ Full S3 Publisher can be found [here](../other-specifications/publishers/s3).
   }
 }
 ```
-Full local source can be found [here](../other-specifications/sources/local).
+Full local source can be found [here](../../other-specifications/sources/local.md).
 
 Remember, the exact keys and values in the `Params` map will vary depending on the specific requirements of the component being configured. Always refer to the individual component's documentation to understand the available parameters.
\ No newline at end of file
diff --git a/docs/docs/references/job-specification/state.md b/docs/docs/setting-up/jobs/job-specification/state.md
similarity index 100%
rename from docs/docs/references/job-specification/state.md
rename to docs/docs/setting-up/jobs/job-specification/state.md
diff --git a/docs/docs/references/job-specification/task.md b/docs/docs/setting-up/jobs/job-specification/task.md
similarity index 78%
rename from docs/docs/references/job-specification/task.md
rename to docs/docs/setting-up/jobs/job-specification/task.md
index 5820e8015f..3e0e8aedda 100644
--- a/docs/docs/references/job-specification/task.md
+++ b/docs/docs/setting-up/jobs/job-specification/task.md
@@ -8,11 +8,11 @@ A `Task` signifies a distinct unit of work within the broader context of a `Job`
 
 ## `Task` Parameters
 - **Name** `(string : <required>)`: A unique identifier representing the name of the task.
-- **Engine** `(`[`SpecConfig`](./spec-config)` : required)`: Configures the execution engine for the task, such as [Docker](../other-specifications/engines/docker) or [WebAssembly](../other-specifications/engines/wasm).
-- **Publisher** `(`[`SpecConfig`](./spec-config)` : optional)`: Specifies where the results of the task should be published, such as [S3](../other-specifications/publishers/s3) and [IPFS](../other-specifications/publishers/ipfs) publishers. Only applicable for tasks of type `batch` and `ops`.
+- **Engine** `(`[`SpecConfig`](./spec-config)` : required)`: Configures the execution engine for the task, such as [Docker](../../other-specifications/engines/docker) or [WebAssembly](../../other-specifications/engines/wasm).
+- **Publisher** `(`[`SpecConfig`](./spec-config)` : optional)`: Specifies where the results of the task should be published, such as [S3](../../other-specifications/publishers/s3) and [IPFS](../../other-specifications/publishers/ipfs) publishers. Only applicable for tasks of type `batch` and `ops`.
 - **Env** `(map[string]string : optional)`: A set of environment variables for the driver.
 - **Meta** `(`[`Meta`](./meta.md)` : optional)`: Allows association of arbitrary metadata with this task.
-- **InputSources** `(`[`InputSource`](./input-source.md)`[] : optional)`: Lists remote artifacts that should be downloaded before task execution and mounted within the task, such as from [S3](../other-specifications/sources/s3) or [HTTP/HTTPs](../other-specifications/sources/url).
+- **InputSources** `(`[`InputSource`](./input-source.md)`[] : optional)`: Lists remote artifacts that should be downloaded before task execution and mounted within the task, such as from [S3](../../other-specifications/sources/s3) or [HTTP/HTTPs](../../other-specifications/sources/url).
 - **ResultPaths** `(`[`ResultPath`](./result-path.md)`[] : optional)`: Indicates volumes within the task that should be included in the published result. Only applicable for tasks of type `batch` and `ops`.
 - **Resources** `(`[`Resources`](./resources.md)` : optional)`: Details the resources that this task requires.
 - **Network** `(`[`Network`](./network.md)` : optional)`: Configurations related to the networking aspects of the task.
diff --git a/docs/docs/references/job-specification/timeouts.md b/docs/docs/setting-up/jobs/job-specification/timeouts.md
similarity index 100%
rename from docs/docs/references/job-specification/timeouts.md
rename to docs/docs/setting-up/jobs/job-specification/timeouts.md
diff --git a/docs/docs/topic-guides/job-templating.md b/docs/docs/setting-up/jobs/job-templating.md
similarity index 91%
rename from docs/docs/topic-guides/job-templating.md
rename to docs/docs/setting-up/jobs/job-templating.md
index 2daf2ebd40..d04dcd4a5f 100644
--- a/docs/docs/topic-guides/job-templating.md
+++ b/docs/docs/setting-up/jobs/job-templating.md
@@ -1,6 +1,6 @@
 ---
 sidebar_label: 'Job Templates'
-sidebar_position: 0
+sidebar_position: 3
 title: 'Job Templates'
 description: Templating Support in Bacalhau Job Run
 ---
@@ -8,7 +8,7 @@ description: Templating Support in Bacalhau Job Run
 
 ## Overview
 
-This documentation introduces templating support for [`bacalhau job run`](/references/cli/job/run), providing users with the ability to dynamically inject variables into their job specifications. This feature is particularly useful when running multiple jobs with varying parameters such as DuckDB query, S3 buckets, prefixes, and time ranges without the need to edit each job specification file manually.
+This documentation introduces templating support for [`bacalhau job run`](../../dev/cli-reference/cli/job/run), providing users with the ability to dynamically inject variables into their job specifications. This feature is particularly useful when running multiple jobs with varying parameters such as DuckDB query, S3 buckets, prefixes, and time ranges without the need to edit each job specification file manually.
 
 ## Motivation
 
diff --git a/docs/docs/topic-guides/job-types.md b/docs/docs/setting-up/jobs/job-types.md
similarity index 98%
rename from docs/docs/topic-guides/job-types.md
rename to docs/docs/setting-up/jobs/job-types.md
index 05592b4620..d1dfd029b5 100644
--- a/docs/docs/topic-guides/job-types.md
+++ b/docs/docs/setting-up/jobs/job-types.md
@@ -1,6 +1,6 @@
 ---
 sidebar_label: 'Job Types'
-sidebar_position: 0
+sidebar_position: 4
 title: 'Job Types'
 description: The different job types available in Bacalhau
 ---
@@ -15,7 +15,7 @@ Despite the differences in job types, all jobs benefit from core functionalities
 3. **Retries** - within limits, Bacalhau will retry certain jobs a set number of times should it fail to complete successfully when requested.
 
 
-## Batch Jobs
+## 1 Batch Jobs
 
 Batch jobs are executed on demand, running on a specified number of Bacalhau nodes. These jobs either run until completion or until they reach a timeout. They are designed to carry out a single, discrete task before finishing.
 
diff --git a/docs/docs/setting-up/join-compute.md b/docs/docs/setting-up/join-compute.md
new file mode 100644
index 0000000000..98ba7dbc96
--- /dev/null
+++ b/docs/docs/setting-up/join-compute.md
@@ -0,0 +1,236 @@
+---
+sidebar_label: 'Join as Compute Provider'
+sidebar_position: 100
+toc_max_heading_level: 4
+---
+
+# Join as Compute Provider
+
+Bacalhau is a peer-to-peer network of computing providers that will run jobs submitted by users. A Compute Provider (CP) is anyone who is running a Bacalhau compute node participating in the Bacalhau compute network, regardless of whether they are hosting any Filecoin data.
+
+This section will show you how to configure and run a Bacalhau node and start accepting and running jobs.
+
+To bootstrap your node and join the network as a CP you can leap right into the [Ubuntu 22.04 quick start](#quick-start-ubuntu-2204) below, or find more setup details in these guides:
+
+* [Networking](https://docs.bacalhau.org/running-node/networking)
+* [Storage Providers](https://docs.bacalhau.org/running-node/storage-providers)
+* [Job Selection Policy](https://docs.bacalhau.org/running-node/job-selection)
+* [Resource Limits](https://docs.bacalhau.org/running-node/resource-limits)
+* [GPU Support](https://docs.bacalhau.org/running-node/gpu)
+* [Windows Support](https://docs.bacalhau.org/running-node/windows-support) (with limitations)
+
+:::info
+
+If you run on a different system than Ubuntu, drop us a message on [Slack](https://bit.ly/bacalhau-project-slack/archives/C02RLM3JHUY)!
+We'll add instructions for your favorite OS.
+
+:::
+
+## Quick start (Ubuntu 22.04)
+
+Estimated time for completion: 10 min.
+
+Tested on: Ubuntu 22.04 LTS (x86/64) running on a GCP e2-standard-4 (4 vCPU, 16 GB memory) instance with 40 GB disk size.
+
+### Prerequisites
+
+* Docker Engine - to take on Docker workloads
+* Connection to storage provider - for storing job's results
+* Firewall - to ensure your node can communicate with the rest of the network
+* Physical hardware, Virtual Machine, or cloud-based host. A Bacalhau compute node is not intended to be run from within a Docker container.
+
+#### Install Docker
+
+To run docker-based workloads, you should have docker installed and running.
+
+If you already have it installed and want to configure the connection to Docker with the following environment variables:
+
+* `DOCKER_HOST` to set the URL to the docker server.
+* `DOCKER_API_VERSION` to set the version of the API to reach, leave empty for "latest".
+* `DOCKER_CERT_PATH` to load the TLS certificates from.
+* `DOCKER_TLS_VERIFY` to enable or disable TLS verification, off by default.
+
+If you do not have Docker on your system, you can follow the official [docker installation instructions](https://docs.docker.com/engine/install/) or just use the snippet below:
+
+```bash
+# install dependencies
+sudo apt-get update
+sudo apt-get install \
+    ca-certificates \
+    curl \
+    gnupg \
+    lsb-release
+
+# add package repo and key
+sudo mkdir -p /etc/apt/keyrings
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
+  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+
+# install docker
+sudo apt-get update
+sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin
+```
+
+Now make [Docker manageable by a non-root user](https://docs.docker.com/engine/install/linux-postinstall/#:~:text=The%20Docker%20daemon%20always%20runs,members%20of%20the%20docker%20group):
+
+```bash
+sudo groupadd docker
+sudo usermod -aG docker $USER
+```
+
+#### Ensure your Storage Server is Running
+
+We will need to connect our Bacalhau node to a storage server for this we will be using IPFS server so we can run jobs that consume CIDs as inputs.
+
+You can either install and run it locally or you can connect to a remote IPFS server.
+
+In both cases - we should have a [multiaddress](https://richardschneider.github.io/net-ipfs-core/articles/multiaddress.html) for our IPFS server that should look something like this:
+
+```bash
+export IPFS_CONNECT=/ip4/10.1.10.10/tcp/80/p2p/QmVcSqVEsvm5RR9mBLjwpb2XjFVn5bPdPL69mL8PH45pPC
+```
+
+:::caution
+
+The multiaddress above is just an example - you need to get the multiaddress of the server you want to connect to.
+
+:::
+
+To install a single IPFS node locally on Ubuntu you can follow the [official instructions](https://docs.ipfs.tech/install/ipfs-desktop/#ubuntu), or follow the steps below. We advise running the same IPFS version as the Bacalhau main network.
+
+Using the command below:
+
+```bash
+export IPFS_VERSION=$(wget -q -O - https://raw.githubusercontent.com/filecoin-project/bacalhau/main/ops/terraform/prod.tfvars | grep --color=never ipfs_version | awk -F'"' '{print $2}')
+```
+
+Install:
+
+```bash
+wget "https://dist.ipfs.tech/go-ipfs/${IPFS_VERSION}/go-ipfs_${IPFS_VERSION}_linux-amd64.tar.gz"
+tar -xvzf "go-ipfs_${IPFS_VERSION}_linux-amd64.tar.gz"
+cd go-ipfs
+sudo bash install.sh
+ipfs --version
+```
+
+Configure:
+
+```bash
+sudo mkdir -p /data/ipfs
+export IPFS_PATH=/data/ipfs
+sudo chown $(id -un):$(id -gn) ${IPFS_PATH} # change ownership of ipfs directory
+ipfs init
+```
+
+Now launch the IPFS daemon **in a separate terminal** (make sure to export the `IPFS_PATH` environment variable there as well):
+
+```bash
+ipfs daemon
+```
+
+:::info
+
+If you want to run the IPFS daemon as a [systemd](https://en.wikipedia.org/wiki/Systemd) service, here's an example [systemd service file](https://github.com/bacalhau-project/bacalhau/blob/main/ops/terraform/remote_files/configs/ipfs.service).
+
+:::
+
+Don't forget we need to fetch an [IPFS multiaddress](https://richardschneider.github.io/net-ipfs-core/articles/multiaddress.html) pointing to our local node.
+
+Use the following command to print out a number of addresses.
+
+```bash
+ipfs id
+```
+
+```json
+{
+        "ID": "12D3KooWNhRU6H1eeqvT1jQAXFAdFDvT5H4AEGmHV7N1cYbzYh1F",
+        "PublicKey": "CAESIL9gmDyR6IgM7ym1JmJ8JKL7NvEgIEGaWwssanl1ieuW",
+        "Addresses": [
+                "/ip4/10.128.0.11/tcp/4001/p2p/12D3KooWNhRU6H1eeqvT1jQAXFAdFDvT5H4AEGmHV7N1cYbzYh1F",
+                "/ip4/10.128.0.11/udp/4001/quic/p2p/12D3KooWNhRU6H1eeqvT1jQAXFAdFDvT5H4AEGmHV7N1cYbzYh1F",
+                "/ip4/127.0.0.1/tcp/4001/p2p/12D3KooWNhRU6H1eeqvT1jQAXFAdFDvT5H4AEGmHV7N1cYbzYh1F",
+                "/ip4/127.0.0.1/udp/4001/quic/p2p/12D3KooWNhRU6H1eeqvT1jQAXFAdFDvT5H4AEGmHV7N1cYbzYh1F",
+                ...
+        ],
+        "AgentVersion": "go-ipfs/0.12.2/",
+        "ProtocolVersion": "ipfs/0.1.0",
+        "Protocols": [
+                "/ipfs/bitswap",
+                ...
+                "/p2p/id/delta/1.0.0",
+                "/x/"
+        ]
+}
+```
+
+I pick the record that combines `127.0.0.1` and `tcp` but I replace port `4001` with `5001`:
+
+```bash
+export IPFS_CONNECT=/ip4/127.0.0.1/tcp/5001/p2p/12D3KooWNhRU6H1eeqvT1jQAXFAdFDvT5H4AEGmHV7N1cYbzYh1F
+```
+
+#### Configure firewall
+
+To ensure that our node can communicate with other nodes on the network - we need to make sure the **1235** port is open.
+
+(Optional) To ensure the CLI can communicate with our node directly (i.e. `bacalhau --api-host <MY_NODE_PUBLIC_IP> version`) - we need to make sure the **1234** port is open.
+
+Firewall configuration is very specific to your network and we can't provide generic instructions for this step but if you need any help feel free to reach out on [Slack!](https://bit.ly/bacalhau-project-slack/archives/C02RLM3JHUY)
+
+### Install the Bacalhau Binary
+
+[Install the bacalhau binary](/getting-started/installation#install-the-bacalhau-client) to run `bacalhau serve`.
+
+:::info
+
+If you want to run Bacalhau as a [systemd](https://en.wikipedia.org/wiki/Systemd) service, here's an example [systemd service file](https://github.com/bacalhau-project/bacalhau/blob/main/ops/terraform/remote_files/configs/bacalhau.service).
+
+:::
+
+### Run bacalhau
+
+Now we can run our bacalhau node:
+
+```bash
+LOG_LEVEL=debug BACALHAU_ENVIRONMENT=production \
+  bacalhau serve \
+    --node-type compute \
+    --ipfs-connect $IPFS_CONNECT \
+    --private-internal-ipfs=false \
+    --peer env
+```
+
+Alternatively, you can run the following Docker command:
+
+```bash
+docker run -it --rm \
+  -e LOG_LEVEL=debug \
+  -e BACALHAU_ENVIRONMENT=production \
+  ghcr.io/bacalhau-project/bacalhau:latest serve \
+    --node-type compute \
+    --ipfs-connect $IPFS_CONNECT \
+    --private-internal-ipfs=false \
+    --peer env
+```
+
+These commands join this node to the public Bacalhau network, congrats! :tada:
+
+### Check your node works
+
+Even though the CLI (by default) submits jobs, each node listens for events on the global network and possibly bids for taking a job: your logs should therefore show the activity of your node bidding for incoming jobs.
+
+To quickly check your node runs properly, let's submit the following dummy job:
+
+```bash
+bacalhau docker run ubuntu echo Test
+```
+
+If you see logs of your compute node bidding for the job above it means you've successfully joined Bacalhau as a Compute Provider!
+
+### What's next?
+
+At this point, you probably have a number of questions for us. What incentive should you expect for running a public Bacalhau node?
+Please contact us on [Slack](https://bit.ly/bacalhau-project-slack/archives/C02RLM3JHUY) to further discuss this topic and for sharing your valuable feedback.
diff --git a/docs/docs/running-node/networking.md b/docs/docs/setting-up/networking-instructions/fundamentals.md
similarity index 97%
rename from docs/docs/running-node/networking.md
rename to docs/docs/setting-up/networking-instructions/fundamentals.md
index e358eaa616..b484aed379 100644
--- a/docs/docs/running-node/networking.md
+++ b/docs/docs/setting-up/networking-instructions/fundamentals.md
@@ -1,9 +1,9 @@
 ---
-sidebar_label: 'Networking'
-sidebar_position: 120
+sidebar_label: 'Fundamentals'
+sidebar_position: 1
 ---
 
-# Networking
+# Networking Fundamentals in Bacalhau
 
 Bacalhau uses [libp2p](https://libp2p.io/) under the hood to communicate with other nodes on the network.
 
diff --git a/docs/docs/setting-up/networking-instructions/index.md b/docs/docs/setting-up/networking-instructions/index.md
new file mode 100644
index 0000000000..56ab55d9dc
--- /dev/null
+++ b/docs/docs/setting-up/networking-instructions/index.md
@@ -0,0 +1,11 @@
+---
+sidebar_label: "Networking"
+sidebar_position: 1
+---
+# Networking with Bacalhau
+
+This directory contains instructions on how to setup the networking in Bacalhau.
+
+
+
+
diff --git a/docs/docs/next-steps/networking.md b/docs/docs/setting-up/networking-instructions/networking.md
similarity index 95%
rename from docs/docs/next-steps/networking.md
rename to docs/docs/setting-up/networking-instructions/networking.md
index a1076e7166..65547d2540 100644
--- a/docs/docs/next-steps/networking.md
+++ b/docs/docs/setting-up/networking-instructions/networking.md
@@ -1,6 +1,6 @@
 ---
 sidebar_position: 4
-sidebar_label: "Networking"
+sidebar_label: "Internet Access"
 ---
 
 # Accessing the Internet from Jobs
@@ -11,7 +11,7 @@ However, by using data volumes you can read and access your data from within job
 
 ## Using Data Volumes
 
-When you submit a Bacalhau job, you'll need to specify the internet locations to download data from and write results to. Both [Docker](../getting-started/docker-workload-onboarding.md) and [WebAssembly](../getting-started/wasm-workload-onboarding.md) jobs support these features.
+When you submit a Bacalhau job, you'll need to specify the internet locations to download data from and write results to. Both [Docker](../workload-onboarding/docker-workload-onboarding.md) and [WebAssembly](../workload-onboarding/wasm-workload-onboarding.md) jobs support these features.
 
 When submitting a Bacalhau job, you can specify the CID (Content IDentifier) or HTTP(S) URL to download data from. The data will be retrieved before the job starts and made available to the job as a directory on the filesystem. When running Bacalhau jobs, you can specify as many CIDs or URLs as needed using `--input` which is accepted by both `bacalhau docker run` and `bacalhau wasm run`. See [command line flags](https://docs.bacalhau.org/all-flags) for more information.
 
diff --git a/docs/docs/next-steps/private-cluster.md b/docs/docs/setting-up/networking-instructions/private-cluster.md
similarity index 100%
rename from docs/docs/next-steps/private-cluster.md
rename to docs/docs/setting-up/networking-instructions/private-cluster.md
diff --git a/docs/docs/references/other-specifications/_category_.yml b/docs/docs/setting-up/other-specifications/_category_.yml
similarity index 100%
rename from docs/docs/references/other-specifications/_category_.yml
rename to docs/docs/setting-up/other-specifications/_category_.yml
diff --git a/docs/docs/references/other-specifications/engines/_category_.yml b/docs/docs/setting-up/other-specifications/engines/_category_.yml
similarity index 100%
rename from docs/docs/references/other-specifications/engines/_category_.yml
rename to docs/docs/setting-up/other-specifications/engines/_category_.yml
diff --git a/docs/docs/references/other-specifications/engines/docker.md b/docs/docs/setting-up/other-specifications/engines/docker.md
similarity index 100%
rename from docs/docs/references/other-specifications/engines/docker.md
rename to docs/docs/setting-up/other-specifications/engines/docker.md
diff --git a/docs/docs/references/other-specifications/engines/wasm.md b/docs/docs/setting-up/other-specifications/engines/wasm.md
similarity index 77%
rename from docs/docs/references/other-specifications/engines/wasm.md
rename to docs/docs/setting-up/other-specifications/engines/wasm.md
index 548aba9efe..e65ffb01d0 100644
--- a/docs/docs/references/other-specifications/engines/wasm.md
+++ b/docs/docs/setting-up/other-specifications/engines/wasm.md
@@ -8,7 +8,7 @@ sidebar_label: Wasm
 
 ## `WASM` Engine Parameters
 
-- **EntryModule** `(`[`InputSource`](../../job-specification/input-source.md)` : required)`: Specifies the WASM module that contains the start function or the main execution code of the task. The InputSource should point to the location of the WASM binary.
+- **EntryModule** `(`[`InputSource`](../../jobs/job-specification/input-source.md)` : required)`: Specifies the WASM module that contains the start function or the main execution code of the task. The InputSource should point to the location of the WASM binary.
 
 - **Entrypoint** `(string: <optional>)`: The name of the function within the EntryModule to execute. For WASI jobs, this should typically be `_start`. The entrypoint function should have zero parameters and zero results.
 
@@ -16,7 +16,7 @@ sidebar_label: Wasm
 
 - **EnvironmentVariables** `(map[string]string: <optional>)`: A mapping of environment variable keys to their values, made available within the executing WASM environment.
 
-- **ImportModules** `(`[`InputSource`](../../job-specification/input-source.md)`[] : optional)`: An array of InputSources pointing to additional WASM modules. The exports from these modules will be available as imports to the EntryModule, enabling modular and reusable WASM code.
+- **ImportModules** `(`[`InputSource`](../../jobs/job-specification/input-source.md)`[] : optional)`: An array of InputSources pointing to additional WASM modules. The exports from these modules will be available as imports to the EntryModule, enabling modular and reusable WASM code.
 
 ### Example
 
diff --git a/docs/docs/references/other-specifications/publishers/_category_.yml b/docs/docs/setting-up/other-specifications/publishers/_category_.yml
similarity index 100%
rename from docs/docs/references/other-specifications/publishers/_category_.yml
rename to docs/docs/setting-up/other-specifications/publishers/_category_.yml
diff --git a/docs/docs/references/other-specifications/publishers/ipfs.md b/docs/docs/setting-up/other-specifications/publishers/ipfs.md
similarity index 100%
rename from docs/docs/references/other-specifications/publishers/ipfs.md
rename to docs/docs/setting-up/other-specifications/publishers/ipfs.md
diff --git a/docs/docs/references/other-specifications/publishers/s3.md b/docs/docs/setting-up/other-specifications/publishers/s3.md
similarity index 95%
rename from docs/docs/references/other-specifications/publishers/s3.md
rename to docs/docs/setting-up/other-specifications/publishers/s3.md
index 7e69a2b02d..fdf1a03598 100644
--- a/docs/docs/references/other-specifications/publishers/s3.md
+++ b/docs/docs/setting-up/other-specifications/publishers/s3.md
@@ -30,7 +30,9 @@ Results published to S3 are stored as objects that can also be used as inputs to
 - **VersionID**: The version ID of the stored object, enabling versioning support for retrieving specific versions of stored data.
 - **ChecksumSHA256**: The SHA-256 checksum of the stored object, providing a method to verify data integrity.
 
-**Note:** `ChecksumSHA256` and `VersionID` are only returned when the `Compress` option is enabled, offering users a method to verify the integrity of the compressed data and to track different versions of the stored objects.
+**Note:** 
+- `ChecksumSHA256` and `VersionID` are only returned when the `Compress` option is enabled, offering users a method to verify the integrity of the compressed data and to track different versions of the stored objects.
+- `ChecksumSHA256` is set only when working with AWS S3, but is not set for all other S3-compatible services.
 
 
 ## Dynamic Naming
@@ -41,9 +43,11 @@ Bacalhau supports the following dynamic placeholders that will be replaced with
 
 - `{executionID}`: Replaced with the specific execution ID.
 - `{jobID}`: Replaced with the ID of the job.
+- `{nodeID}`: Replaced with the ID of the node where the execution took place
 - `{date}`: Replaced with the current date in the format `YYYYMMDD`.
 - `{time}`: Replaced with the current time in the format `HHMMSS`.
 
+
 Additionally, if you are publishing an archive and the object key does not end with `.tar.gz`, it will be automatically appended. Conversely, if you're not archiving and the key doesn't end with a `/`, a trailing slash will be added.
 
 **Example**
diff --git a/docs/docs/references/other-specifications/sources/_category_.yml b/docs/docs/setting-up/other-specifications/sources/_category_.yml
similarity index 100%
rename from docs/docs/references/other-specifications/sources/_category_.yml
rename to docs/docs/setting-up/other-specifications/sources/_category_.yml
diff --git a/docs/docs/references/other-specifications/sources/ipfs.md b/docs/docs/setting-up/other-specifications/sources/ipfs.md
similarity index 100%
rename from docs/docs/references/other-specifications/sources/ipfs.md
rename to docs/docs/setting-up/other-specifications/sources/ipfs.md
diff --git a/docs/docs/references/other-specifications/sources/local.md b/docs/docs/setting-up/other-specifications/sources/local.md
similarity index 100%
rename from docs/docs/references/other-specifications/sources/local.md
rename to docs/docs/setting-up/other-specifications/sources/local.md
diff --git a/docs/docs/references/other-specifications/sources/s3.md b/docs/docs/setting-up/other-specifications/sources/s3.md
similarity index 100%
rename from docs/docs/references/other-specifications/sources/s3.md
rename to docs/docs/setting-up/other-specifications/sources/s3.md
diff --git a/docs/docs/references/other-specifications/sources/url.md b/docs/docs/setting-up/other-specifications/sources/url.md
similarity index 100%
rename from docs/docs/references/other-specifications/sources/url.md
rename to docs/docs/setting-up/other-specifications/sources/url.md
diff --git a/docs/docs/running-node/_category_.yml b/docs/docs/setting-up/running-node/_category_.yml
similarity index 100%
rename from docs/docs/running-node/_category_.yml
rename to docs/docs/setting-up/running-node/_category_.yml
diff --git a/docs/docs/running-node/auth.md b/docs/docs/setting-up/running-node/auth.md
similarity index 99%
rename from docs/docs/running-node/auth.md
rename to docs/docs/setting-up/running-node/auth.md
index 2a409e0f91..228c9cfece 100644
--- a/docs/docs/running-node/auth.md
+++ b/docs/docs/setting-up/running-node/auth.md
@@ -36,14 +36,18 @@ Restricting the list of keys that can authenticate to only a known set requires
 specifying a new **authentication policy**. You can download a policy that
 restricts key-based access and install it by using:
 
+```
     curl -sL https://raw.githubusercontent.com/bacalhau-project/bacalhau/main/pkg/authn/challenge/challenge_ns_no_anon.rego -o ~/.bacalhau/challenge_ns_no_anon.rego
     bacalhau config set Node.Auth.Methods.ClientKey.Type challenge
     bacalhau config set Node.Auth.Methods.ClientKey.PolicyPath ~/.bacalhau/challenge_ns_no_anon.rego
+```
 
 Then, modify the `allowed_clients` variable in `challange_ns_no_anon.rego` to
 include acceptable client IDs, found by running `bacalhau id`.
 
+```
     bacalhau id | jq -rc .ClientID
+```
 
 Once the node is restarted, only keys in the allowed list will be able to access
 any API.
diff --git a/docs/docs/running-node/configuration.md b/docs/docs/setting-up/running-node/configuration.md
similarity index 100%
rename from docs/docs/running-node/configuration.md
rename to docs/docs/setting-up/running-node/configuration.md
diff --git a/docs/docs/running-node/configuring-tls.md b/docs/docs/setting-up/running-node/configuring-tls.md
similarity index 100%
rename from docs/docs/running-node/configuring-tls.md
rename to docs/docs/setting-up/running-node/configuring-tls.md
diff --git a/docs/docs/running-node/gpu.md b/docs/docs/setting-up/running-node/gpu.md
similarity index 100%
rename from docs/docs/running-node/gpu.md
rename to docs/docs/setting-up/running-node/gpu.md
diff --git a/docs/docs/running-node/index.md b/docs/docs/setting-up/running-node/index.md
similarity index 72%
rename from docs/docs/running-node/index.md
rename to docs/docs/setting-up/running-node/index.md
index b2258d1e76..243828167a 100644
--- a/docs/docs/running-node/index.md
+++ b/docs/docs/setting-up/running-node/index.md
@@ -1,4 +1,6 @@
 ---
 sidebar_label: 'Running Node'
 sidebar_position: 6
----
\ No newline at end of file
+---
+
+# Running a Node
\ No newline at end of file
diff --git a/docs/docs/running-node/job-selection.md b/docs/docs/setting-up/running-node/job-selection.md
similarity index 98%
rename from docs/docs/running-node/job-selection.md
rename to docs/docs/setting-up/running-node/job-selection.md
index 16c7e96232..52dc31b8b5 100644
--- a/docs/docs/running-node/job-selection.md
+++ b/docs/docs/setting-up/running-node/job-selection.md
@@ -15,7 +15,7 @@ policy.
 | Node.Compute.JobSelection.ProbeExec | `--job-selection-probe-exec` | unused | Use the result of an external program to decide if we should take on the job. |
 | Node.Compute.JobSelection.ProbeHttp | `--job-selection-probe-http` | unused | Use the result of a HTTP POST to decide if we should take on the job. |
 | Node.Compute.JobSelection.RejectStatelessJobs | `--job-selection-reject-stateless` | False | Reject jobs that don't specify any [input data](../data-ingestion/index.md). |
-| Node.Compute.JobSelection.AcceptNetworkedJobs | `--job-selection-accept-networked` | False | Accept jobs that require [network connections](../next-steps/networking.md). |
+| Node.Compute.JobSelection.AcceptNetworkedJobs | `--job-selection-accept-networked` | False | Accept jobs that require [network connections](../networking-instructions/networking.md). |
 
 ## Job selection probes
 
diff --git a/docs/docs/running-node/observability.md b/docs/docs/setting-up/running-node/observability.md
similarity index 100%
rename from docs/docs/running-node/observability.md
rename to docs/docs/setting-up/running-node/observability.md
diff --git a/docs/docs/running-node/persistence.md b/docs/docs/setting-up/running-node/persistence.md
similarity index 100%
rename from docs/docs/running-node/persistence.md
rename to docs/docs/setting-up/running-node/persistence.md
diff --git a/docs/docs/running-node/quick-start-docker.md b/docs/docs/setting-up/running-node/quick-start-docker.md
similarity index 100%
rename from docs/docs/running-node/quick-start-docker.md
rename to docs/docs/setting-up/running-node/quick-start-docker.md
diff --git a/docs/docs/running-node/quick-start.md b/docs/docs/setting-up/running-node/quick-start.md
similarity index 100%
rename from docs/docs/running-node/quick-start.md
rename to docs/docs/setting-up/running-node/quick-start.md
diff --git a/docs/docs/running-node/resource-limits.md b/docs/docs/setting-up/running-node/resource-limits.md
similarity index 100%
rename from docs/docs/running-node/resource-limits.md
rename to docs/docs/setting-up/running-node/resource-limits.md
diff --git a/docs/docs/running-node/storage-providers.md b/docs/docs/setting-up/running-node/storage-providers.md
similarity index 100%
rename from docs/docs/running-node/storage-providers.md
rename to docs/docs/setting-up/running-node/storage-providers.md
diff --git a/docs/docs/running-node/timeouts.md b/docs/docs/setting-up/running-node/timeouts.md
similarity index 100%
rename from docs/docs/running-node/timeouts.md
rename to docs/docs/setting-up/running-node/timeouts.md
diff --git a/docs/docs/running-node/webui.md b/docs/docs/setting-up/running-node/webui.md
similarity index 100%
rename from docs/docs/running-node/webui.md
rename to docs/docs/setting-up/running-node/webui.md
diff --git a/docs/docs/running-node/windows-support.md b/docs/docs/setting-up/running-node/windows-support.md
similarity index 100%
rename from docs/docs/running-node/windows-support.md
rename to docs/docs/setting-up/running-node/windows-support.md
diff --git a/docs/docs/next-steps/update-checks.md b/docs/docs/setting-up/update-checks.md
similarity index 60%
rename from docs/docs/next-steps/update-checks.md
rename to docs/docs/setting-up/update-checks.md
index 0cc2608907..74c1f86060 100644
--- a/docs/docs/next-steps/update-checks.md
+++ b/docs/docs/setting-up/update-checks.md
@@ -9,13 +9,20 @@ Bacalhau has an update checking service to automatically detect whether a newer
 
 Users who are both running CLI commands and operating nodes will be regularly informed that a new release can be downloaded and installed.
 
-By default, an update check will run no more than once every 24 hours. Users can opt out of automatic update checks using the configuration described below.
 
 ## For clients
 
 Bacalhau will run an update check regularly when client commands are executed. If an update is available, explanatory text will be printed at the end of the command.
 
-To force a manual update check, run the `bacalhau version` command which will explicitly list the latest software release alongside the server and client versions.
+To force a manual update check, run the `bacalhau version` command, which will explicitly list the latest software release alongside the server and client versions.
+
+```shell
+bacalhau version
+
+Expected Output
+ CLIENT  SERVER  LATEST  UPDATE MESSAGE
+ v1.2.0  v1.2.0  v1.2.0
+```
 
 ## For node operators
 
@@ -25,10 +32,28 @@ If an update is available, an INFO level message will be printed to the log.
 
 ## Configuring checks
 
-Bacalhau has some configuration options for controlling how often checks are performed:
+Bacalhau has some configuration options for controlling how often checks are performed. By default, an update check will run no more than once every 24 hours. Users can opt out of automatic update checks using the configuration described below. 
 
 | Config property | Environment variable | Default value | Meaning |
 |---|---|---|---|
 | Update.SkipChecks | `BACALHAU_UPDATE_SKIPCHECKS` | False | If true, no update checks will be performed. As an environment variable, set to `"1"`, `"t"` or `"true"`. |
 | Update.CheckFrequency | `BACALHAU_UPDATE_CHECKFREQUENCY` | 24 hours | The minimum amount of time between automated update checks. Set as any duration of hours, minutes or seconds, e.g. `24h` or `10m`. |
 | Update.CheckStatePath | `BACALHAU_UPDATE_CHECKSTATEPATH` | $BACALHAU_DIR/update.json | An absolute path where Bacalhau should store the date and time of the last check. |
+
+:::info
+It's important to note that disabling the automatic update checks may lead to potential issues, arising from mismatched versions of different actors within Bacalhau.
+:::
+
+To output update check config, run `bacalhau config list`:
+
+```shell
+bacalhau config list
+
+Expected Output
+...
+update.checkfrequency                                           24h0m0s                                  
+update.checkstatepath                                           /home/user/.bacalhau/update.json  
+update.skipchecks                                               false
+...
+```
+
diff --git a/docs/docs/setting-up/workload-onboarding/CUDA/index.md b/docs/docs/setting-up/workload-onboarding/CUDA/index.md
new file mode 100644
index 0000000000..de5942fa18
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/CUDA/index.md
@@ -0,0 +1,164 @@
+---
+sidebar_label: "CUDA"
+sidebar_position: 10
+---
+# Run CUDA programs on Bacalhau
+
+
+### What is CUDA
+
+In this tutorial, we will look at how to run CUDA programs on Bacalhau. CUDA (Compute Unified Device Architecture) is an extension of C/C++ programming. It is a parallel computing platform and programming model created by NVIDIA. It helps developers speed up their applications by harnessing the power of GPU accelerators.
+
+In addition to accelerating high-performance computing (HPC) and research applications, CUDA has also been widely adopted across consumer and industrial ecosystems. CUDA also makes it easy for developers to take advantage of all the latest GPU architecture innovations
+
+### Advantage of GPU over CPU
+Architecturally, the CPU is composed of just a few cores with lots of cache memory that can handle a few software threads at a time. In contrast, a GPU is composed of hundreds of cores that can handle thousands of threads simultaneously.
+
+Computations like matrix multiplication could be done much faster on GPU than on CPU
+
+### Prerequisite
+
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+
+## 1. Running CUDA locally
+
+You'll need to have the following installed:
+1. NVIDIA GPU
+2. CUDA drivers installed
+3. nvcc installed
+
+Checking if nvcc is installed:
+
+
+```python
+!nvcc --version
+```
+
+Downloading the programs:
+
+
+```bash
+%%bash
+mkdir inputs outputs
+wget -P inputs https://raw.githubusercontent.com/tristanpenman/cuda-examples/master/00-hello-world.cu
+wget -P inputs https://raw.githubusercontent.com/tristanpenman/cuda-examples/master/02-cuda-hello-world-faster.cu
+```
+
+### Viewing the programs
+
+1. **`00-hello-world.cu`**:
+
+```bash
+# View the contents of the standard C++ program
+!cat inputs/00-hello-world.cu
+
+# Measure the time it takes to compile and run the program
+%%timeit
+!nvcc -o ./outputs/hello ./inputs/00-hello-world.cu; ./outputs/hello
+```
+This example represents a standard C++ program that inefficiently utilizes GPU resources due to the use of non-parallel loops.
+
+
+2. **`02-cuda-hello-world-faster.cu`**:
+
+```bash
+# View the contents of the CUDA program with vector addition
+!cat inputs/02-cuda-hello-world-faster.cu
+
+# Remove any previous output 
+!rm -rf outputs/hello
+
+# Measure the time for compilation and execution
+%%timeit
+!nvcc --expt-relaxed-constexpr -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu; ./outputs/hello
+```
+
+In this example we utilize Vector addition using CUDA and allocate the memory in advance and copy the memory to the GPU using cudaMemcpy so that it can utilize the HBM (High Bandwidth memory of the GPU).
+Compilation and execution occur faster (1.39 seconds) compared to the previous example (8.67 seconds).
+
+## 2. Running a Bacalhau Job
+
+To submit a job, run the following Bacalhau command:
+
+
+```bash
+%%bash --out job_id
+bacalhau docker run \
+    --gpu 1 \
+    --timeout 3600 \
+    --wait-timeout-secs 3600 \
+    -i https://raw.githubusercontent.com/tristanpenman/cuda-examples/master/02-cuda-hello-world-faster.cu \
+    --id-only \
+    --wait \
+    nvidia/cuda:11.2.2-cudnn8-devel-ubuntu18.04 \
+    -- /bin/bash -c 'nvcc --expt-relaxed-constexpr  -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu; ./outputs/hello '
+```
+
+### Structure of the Commands
+
+`bacalhau docker run`: call to Bacalhau
+
+`-i https://raw.githubusercontent.com/tristanpenman/cuda-examples/master/02-cuda-hello-world-faster.cu`: URL path of the input data volumes downloaded from a URL source.
+
+`nvidia/cuda:11.2.0-cudnn8-devel-ubuntu18.04`: Docker container for executing CUDA programs (you need to choose the right CUDA docker container). The container should have the tag of "devel" in them.
+
+`nvcc --expt-relaxed-constexpr  -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu`: Compilation using the nvcc compiler and save it to the outputs directory as hello
+
+Note that there is `;` between the commands:
+  `-- /bin/bash -c 'nvcc --expt-relaxed-constexpr  -o ./outputs/hello ./inputs/02-cuda-hello-world-faster.cu; ./outputs/hello ` The ";" symbol allows executing multiple commands sequentially in a single line. 
+
+`./outputs/hello`: Execution hello binary:
+You can combine compilation and execution commands. 
+
+:::info
+Note that the CUDA version will need to be compatible with the graphics card on the host machine.
+:::
+
+When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
+
+```python
+%env JOB_ID={job_id}
+```
+
+## 3. Checking the State of your Jobs
+
+**Job status**: You can check the status of the job using `bacalhau list`.
+
+
+```bash
+%%bash
+bacalhau list --id-filter ${JOB_ID} --wide
+```
+
+When it says `Published` or `Completed`, that means the job is done, and we can get the results.
+
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
+
+
+
+```bash
+%%bash
+bacalhau describe ${JOB_ID}
+```
+
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
+
+
+```bash
+%%bash
+rm -rf results && mkdir -p results
+bacalhau get $JOB_ID --output-dir results
+```
+
+## 4. Viewing your Job Output
+
+To view the file, run the following command:
+
+
+```bash
+%%bash
+cat results/stdout 
+```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/Prolog-Hello-World/index.md b/docs/docs/setting-up/workload-onboarding/Prolog-Hello-World/index.md
similarity index 51%
rename from docs/docs/examples/workload-onboarding/Prolog-Hello-World/index.md
rename to docs/docs/setting-up/workload-onboarding/Prolog-Hello-World/index.md
index dfd8dc6d89..214a7cf354 100644
--- a/docs/docs/examples/workload-onboarding/Prolog-Hello-World/index.md
+++ b/docs/docs/setting-up/workload-onboarding/Prolog-Hello-World/index.md
@@ -9,18 +9,16 @@ sidebar_position: 4
 
 ## Introduction
 Prolog is intended primarily as a declarative programming language: the program logic is expressed in terms of relations, represented as facts and rules. A computation is initiated by running a query over these relations.
-Prolog is well-suited for specific tasks that benefit from rule-based logical queries such as searching databases, voice control systems, and filling templates.
+Prolog is well-suited for specific tasks that benefit from rule-based logical queries such as searching databases, voice control systems, and filling templates.  
 
-
-## TD;LR
-A quick guide on how to run a hello world script on Bacalhau
+This tutorial is a quick guide on how to run a hello world script on Bacalhau.
 
 ## Prerequisites
 
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
 
 
-## Running Locally​
+## 1. Running Locally​
 
 
 To get started, install swipl 
@@ -34,7 +32,7 @@ sudo apt-get update
 sudo apt-get install swi-prolog
 ```
 
-Create a file called `helloworld.pl`. The following script prints ‘Hello World’ to the stdout
+Create a file called `helloworld.pl`. The following script prints ‘Hello World’ to the stdout:
 
 
 
@@ -44,7 +42,7 @@ hello_world :- write('Hello World'), nl,
                halt.
 ```
 
-Running the script to print out the output
+Running the script to print out the output:
 
 
 
@@ -72,21 +70,24 @@ Using the `IPFS cli`
 !nohup ipfs daemon > startup.log &
 ```
 
-Run the command below to check if our script has been uploaded. This command outputs the CID.
+Run the command below to check if our script has been uploaded.
 
 
 ```python
 !ipfs add helloworld.pl
 ```
 
-Copy the CID of the file which in this case is `QmYq9ipYf3vsj7iLv5C67BXZcpLHxZbvFAJbtj7aKN5qii`
+This command outputs the CID. Copy the CID of the file, which in our case is `QmYq9ipYf3vsj7iLv5C67BXZcpLHxZbvFAJbtj7aKN5qii`
+
+Since the data uploaded to IPFS isn’t pinned, we will need to do that manually. Check this information on how to pin your [data](../../../setting-up/data-ingestion/pin.md) We recommend using [NFT.Storage](https://nft.storage/).
 
-Since the data uploaded To IPFS isn’t pinned, we will need to do that manually. Check this information on how to pin your [data](https://docs.bacalhau.org/data-ingestion/pin) We recommend using [NFT.Storage](https://nft.storage/).
 
 
+## 2. Running a Bacalhau Job 
 
-## Running a Bacalhau Job 
 
+We will mount the script to the container using the `-i` flag:  
+ `-i: ipfs://< CID >:/< name-of-the-script >`. 
 
 To submit a job, run the following Bacalhau command:
 
@@ -94,31 +95,35 @@ To submit a job, run the following Bacalhau command:
 ```bash
 %%bash --out job_id
 bacalhau docker run \
--i ipfs://QmYq9ipYf3vsj7iLv5C67BXZcpLHxZbvFAJbtj7aKN5qii:/helloworld.pl \
---wait \
---id-only \
-swipl \
- -- swipl -q -s helloworld.pl -g hello_world
+    -i ipfs://QmYq9ipYf3vsj7iLv5C67BXZcpLHxZbvFAJbtj7aKN5qii:/helloworld.pl \
+    --wait \
+    --id-only \
+    swipl \
+    -- swipl -q -s helloworld.pl -g hello_world
 ```
 
 ### Structure of the Command
 
 
-`-i: ipfs://< CID >:/< name-of-the-script >`: we will mount the script to the container using the -v flag
+`-i ipfs://QmYq9ipYf3vsj7iLv5C67BXZcpLHxZbvFAJbtj7aKN5qii:/helloworld.pl` : Sets the input data for the container. `QmYq9ipYf3vsj7iLv5C67BXZcpLHxZbvFAJbtj7aKN5qii` is our CID which points to the `helloworld.pl` file on the IPFS network. This file will be accessible within the container.
 
-`Swipl`: flag
+`-- swipl -q -s helloworld.pl -g hello_world`: instructs SWI-Prolog to load the program from the `helloworld.pl` file and execute the `hello_world` function in quiet mode:
 
 `-q`: running in quiet mode
 
-`-s`: load file as a script in this case we want to run the script helloworld.pl
+`-s`: load file as a script. In this case we want to run the `helloworld.pl` script
+
+`-g`: is the name of the function you want to execute. In this case its `hello_world`
 
-`-g`: is the name of the function you want to execute in this case its hello_world
+When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
 
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
+```python
+%env JOB_ID={job_id}
+```
 
-## Checking the State of your Jobs
+## 3. Checking the State of your Jobs
 
-- **Job status**: You can check the status of the job using `bacalhau list`. 
+**Job status**: You can check the status of the job using `bacalhau list`. 
 
 
 ```bash
@@ -128,7 +133,7 @@ bacalhau list --id-filter ${JOB_ID} --wide
 
 When it says `Published` or `Completed`, that means the job is done, and we can get the results.
 
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
 
 
 ```bash
@@ -136,7 +141,7 @@ When it says `Published` or `Completed`, that means the job is done, and we can
 bacalhau describe ${JOB_ID}
 ```
 
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
 
 
 ```bash
@@ -145,7 +150,7 @@ rm -rf results && mkdir -p results
 bacalhau get $JOB_ID --output-dir results
 ```
 
-## Viewing your Job Output
+## 4. Viewing your Job Output
 
 To view the file, run the following command:
 
@@ -154,3 +159,6 @@ To view the file, run the following command:
 %%bash
 cat results/stdout
 ```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/Python-Custom-Container/index.md b/docs/docs/setting-up/workload-onboarding/Python-Custom-Container/index.md
similarity index 64%
rename from docs/docs/examples/workload-onboarding/Python-Custom-Container/index.md
rename to docs/docs/setting-up/workload-onboarding/Python-Custom-Container/index.md
index da831aa85b..ea499e65d3 100644
--- a/docs/docs/examples/workload-onboarding/Python-Custom-Container/index.md
+++ b/docs/docs/setting-up/workload-onboarding/Python-Custom-Container/index.md
@@ -11,18 +11,15 @@ sidebar_position: 5
 ## **Introduction**
 
 
-In this tutorial example, we will walk you through building your own docker container and running the container on the bacalhau network.
-
-## TD;LR
-Running a Python container on Bacalhau
+In this tutorial example, we will walk you through building your own Python container and running the container on Bacalhau.
 
 ## Prerequisites
 
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
 
-## Sample Recommendation Dataset
+## 1. Sample Recommendation Dataset
 
-We will be using a simple recommendation script that when given a movie ID will recommend other movies based on user ratings. Assuming you want if recommendations for the movie Toy Story (1995) it will recommend movies from similar categories:
+We will be using a simple recommendation script that, when given a movie ID, recommends other movies based on user ratings. Assuming you want recommendations for the movie 'Toy Story' (1995), it will suggest movies from similar categories:
 
 ```
 Recommendations for Toy Story (1995):
@@ -49,16 +46,7 @@ Download Movielens1M dataset from this link [https://files.grouplens.org/dataset
 !wget https://files.grouplens.org/datasets/movielens/ml-1m.zip
 ```
 
-In this example, we’ll be using 2 files from the MovieLens 1M dataset: ratings.dat and movies.dat. After the dataset is downloaded extract the zip and place ratings.dat and movies.dat into a folder called input
-
-The structure of the input directory should be
-
-```
-input
-├── movies.dat
-└── ratings.dat
-```
-
+In this example, we’ll be using 2 files from the MovieLens 1M dataset: `ratings.dat` and `movies.dat`.After the dataset is downloaded extract the zip and place `ratings.dat` and `movies.dat` into a folder called `input`:
 
 ```python
 # Extracting the downloaded zip file
@@ -71,10 +59,17 @@ input
 !mkdir input; mv ml-1m/movies.dat ml-1m/ratings.dat input/
 ```
 
+The structure of the input directory should be
+
+```
+input
+├── movies.dat
+└── ratings.dat
+```
 
 ### Installing Dependencies
 
-Create a `requirements.txt` for the Python libraries we’ll be using:
+To create a `requirements.txt` for the Python libraries we’ll be using, run:
 
 
 ```python
@@ -83,7 +78,7 @@ numpy
 pandas
 ```
 
-To install the dependencies run the command
+To install the dependencies, run:
 
 
 
@@ -175,27 +170,28 @@ print_similar_movies(movie_data, movie_id, top_indexes)
 
 What the similar-movies.py script does
 
-* Read the files with pandas
-* Create the ratings matrix of shape (m×u) with rows as movies and columns as user
-* Normalise matrix (subtract mean off)
-* Compute SVD
-* Calculate cosine similarity, sort by most similar, and return the top N.
-* Select k principal components to represent the movies, a movie_id to find recommendations, and print the top_n results.
+1. Read the files with pandas. The code uses Pandas to read data from the files `ratings.dat` and `movies.dat`.
+
+2. Create the ratings matrix of shape (m×u) with rows as movies and columns as user
+3. Normalise matrix (subtract mean off). The ratings matrix is normalized by subtracting the mean off.
+4. Compute SVD: a singular value decomposition (SVD) of the normalized ratings matrix is performed.
+5. Calculate cosine similarity, sort by most similar, and return the top N.
+6. Select k principal components to represent the movies, a `movie_id` to find recommendations, and print the `top_n` results.
 
 For further reading on how the script works, go to [Simple Movie Recommender Using SVD | Alyssa](https://alyssaq.github.io/2015/20150426-simple-movie-recommender-using-svd/)
 
 
 ### Running the Script
 
-Running the script similar-movies.py using the default values you can also use other flags to set your own values
-
+Running the script `similar-movies.py` using the default values: 
 
 
 ```python
 ! python similar-movies.py
 ```
+You can also use other flags to set your own values.
 
-## Setting Up Docker
+## 2. Setting Up Docker
 
 We will create a  `Dockerfile` and add the desired configuration to the file. These commands specify how the image will be built, and what extra requirements will be included.
 
@@ -210,7 +206,7 @@ RUN pip install -r requirements.txt
 ```
 
 
-We will use the python:3.8 docker image and add our script `similar-movies.py` to copy the script to the docker image, similarly, we also add the dataset directory and also the requirements, after that run the command to install the dependencies in the image
+We will use the `python:3.8` docker image and add our script `similar-movies.py` to copy the script to the docker image, similarly, we also add the `dataset` directory and also the `requirements`, after that run the command to install the dependencies in the image
 
 The final folder structure will look like this:
 
@@ -231,29 +227,29 @@ See more information on how to containerize your script/app [here](https://docs.
 
 ### Build the container
 
-We will run `docker build` command to build the container;
+We will run `docker build` command to build the container:
 
 ```
 docker build -t <hub-user>/<repo-name>:<tag> .
 ```
 
-Before running the command replace;
+Before running the command replace:
 
-- **hub-user** with your docker hub username, If you don’t have a docker hub account [follow these instructions to create docker account](https://docs.docker.com/docker-id/), and use the username of the account you created
+**`hub-user`** with your docker hub username, If you don’t have a docker hub account [follow these instructions to create a docker account](https://docs.docker.com/docker-id/), and use the username of the account you created
 
-- **repo-name** with the name of the container, you can name it anything you want
+**`repo-name`** with the name of the container, you can name it anything you want
 
-- **tag** this is not required but you can use the latest tag
+**`tag`** this is not required, but you can use the `latest` tag
 
-In our case
+In our case:
 
 ```bash
-docker build -t jsace/python-similar-movies
+docker build -t jsace/python-similar-movies .
 ```
 
 ### Push the container
 
-Next, upload the image to the registry. This can be done by using the Docker hub username, repo name or tag.
+Next, upload the image to the registry. This can be done by using the `Docker hub username`, `repo name` or `tag`.
 
 ```
 docker push <hub-user>/<repo-name>:<tag>
@@ -265,9 +261,9 @@ In our case
 docker push jsace/python-similar-movies
 ```
 
-## Running a Bacalhau Job
+## 3. Running a Bacalhau Job
 
-After the repo image has been pushed to Docker Hub, we can now use the container for running on Bacalhau. You can submit a Bacalhau job using by running your container on Bacalhau with default or custom parameters
+After the repo image has been pushed to Docker Hub, we can now use the container for running on Bacalhau. You can submit a Bacalhau job by running your container on Bacalhau with default or custom parameters.
 
 ### Running the Container with Default Parameters
 
@@ -277,21 +273,19 @@ To submit a Bacalhau job by running your container on Bacalhau with default para
 ```bash
 %%bash --out job_id
 bacalhau docker run \
---id-only \
---wait \
-jsace/python-similar-movies \
--- python similar-movies.py
+    --id-only \
+    --wait \
+    jsace/python-similar-movies \
+    -- python similar-movies.py
 ```
 
 ### Structure of the command
 
-Let's look closely at the command above:
-
-* `bacalhau docker run`: call to bacalhau
+`bacalhau docker run`: call to Bacalhau
 
-* `jsace/python-similar-movies`: the name and the tag of the docker image we are using
+`jsace/python-similar-movies`: the name and of the docker image we are using
 
-* `-- python similar-movies.py`: execute the Python script
+`-- python similar-movies.py`: execute the Python script
 
 When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
 
@@ -302,23 +296,21 @@ To submit a Bacalhau job by running your container on Bacalhau with custom param
 
 ```
 bacalhau docker run \
-jsace/python-similar-movies \
--- python similar-movies.py --k 50 --id 10 --n 10
+    jsace/python-similar-movies \
+    -- python similar-movies.py --k 50 --id 10 --n 10
 ```
 
 ### Structure of the command
 
-Let's look closely at the command above:
+`bacalhau docker run`: call to Bacalhau
 
-* `bacalhau docker run`: call to bacalhau
+`jsace/python-similar-movies`: the name of the docker image we are using
 
-* `jsace/python-similar-movies`: the name and the tag of the docker image we are using
+`-- python similar-movies.py --k 50 --id 10 --n 10`: execute the python script. The script will use Singular Value Decomposition (SVD) and cosine similarity to find 10 movies most similar to the one with identifier 10, using 50 principal components.
 
-* `-- python similar-movies.py --k 50 --id 10 --n 10`: execute the python script
+## 4. Checking the State of your Jobs
 
-## Checking the State of your Jobs
-
-- **Job status**: You can check the status of the job using `bacalhau list`.
+**Job status**: You can check the status of the job using `bacalhau list`.
 
 
 ```bash
@@ -328,7 +320,7 @@ bacalhau list --id-filter ${JOB_ID}
 
 When it says `Published` or `Completed`, that means the job is done, and we can get the results.
 
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
 
 
 ```bash
@@ -336,7 +328,7 @@ When it says `Published` or `Completed`, that means the job is done, and we can
 bacalhau describe ${JOB_ID}
 ```
 
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
 
 
 ```bash
@@ -345,7 +337,7 @@ rm -rf results && mkdir -p results
 bacalhau get $JOB_ID --output-dir results
 ```
 
-## Viewing your Job Output
+## 5. Viewing your Job Output
 
 To view the file, run the following command:
 
@@ -353,3 +345,6 @@ To view the file, run the following command:
 ```python
 !cat results/stdout # displays the contents of the file
 ```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index.md b/docs/docs/setting-up/workload-onboarding/Reading-From-Multiple-S3-Buckets/index.md
similarity index 63%
rename from docs/docs/examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index.md
rename to docs/docs/setting-up/workload-onboarding/Reading-From-Multiple-S3-Buckets/index.md
index 7eae35301e..a1c6c5ced2 100644
--- a/docs/docs/examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index.md
+++ b/docs/docs/setting-up/workload-onboarding/Reading-From-Multiple-S3-Buckets/index.md
@@ -24,51 +24,50 @@ There are several advantages to converting images from TIFF to JPEG format:
 
 ## Running the job on Bacalhau
 
-We will use the S3 mount feature to mount several bucket objects from public s3 buckets located in different regions.
+We will use the S3 mount feature to mount bucket objects from s3 buckets. Let’s have a look at the example below:
 
-Firstly we will demonstrate how to run the job with just one bucket and then run the same job on 5 buckets located in different regions.
+**`-i src=s3://sentinel-s1-rtc-indigo/tiles/RTC/1/IW/10/S/DH/2017/S1A_20170125_10SDH_ASC/Gamma0_VH.tif,dst=/sentinel-s1-rtc-indigo/,opt=region=us-west-2`** It defines S3 object as input to the job:  
 
-### Prerequisite
-
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-
-
-### Running the job on multiple buckets with multiple objects
+`sentinel-s1-rtc-indigo`: bucket’s name  
 
+`tiles/RTC/1/IW/10/S/DH/2017/S1A_20170125_10SDH_ASC/Gamma0_VH.tif`: represents the key of the object in that bucket. The object to be processed is called `Gamma0_VH.tif` and is located in the subdirectory with the specified path.  
 
-```bash
-%%bash --out job_id
-bacalhau docker run \
---wait \
---id-only \
---timeout 3600 \
---wait-timeout-secs 3600 \
--i src=s3://bdc-sentinel-2/s2-16d/v1/075/086/2018/02/18/*,dst=/bdc-sentinel-2/,opt=region=us-west-2  \
--i src=s3://sentinel-cogs/sentinel-s2-l2a-cogs/28/M/CV/2022/6/S2B_28MCV_20220620_0_L2A/*,dst=/sentinel-cogs/,opt=region=us-west-2 \
-jsacex/gdal-s3
-```
+But if you want to specify the entire objects located in the path, you can simply add `*` to the end of the path (`tiles/RTC/1/IW/10/S/DH/2017/S1A_20170125_10SDH_ASC/*`)  
 
-**`-i src=s3://sentinel-s1-rtc-indigo/tiles/RTC/1/IW/10/S/DH/2017/S1A_20170125_10SDH_ASC/Gamma0_VH.tif,dst=/sentinel-s1-rtc-indigo/,opt=region=us-west-2`**
+`dst=/sentinel-s1-rtc-indigo`: the destination to which to mount the s3 bucket object  
 
-Breakdown of the flag:
+`opt=region=us-west-2` : specifying the region in which the bucket is located 
 
-`-i src=s3://sentinel-s1-rtc-indigo/tiles/RTC/1/IW/10/S/DH/2017/S1A_20170125_10SDH_ASC/Gamma0_VH.tif`:
+### Prerequisite
 
-Specifying the bucket source along with the keys in this case it's `s3://bdc-sentinel-2/s2-16d/v1/075/086/2018/02/18/*` but if you want to specify the entire objects located in the path you can simply add `*` to the end of the path `s3://bdc-sentinel-2/s2-16d/v1/075/086/2018/02/18/*`
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
 
-`dst=/bdc-sentinel-2/`: the destination to which to mount the s3 bucket object
 
-`opt=region=us-west-2`: Specifying the region in which the bucket is located
+### TBD 1. Running the job on multiple buckets with multiple objects
 
+In the example below, we will mount several bucket objects from public s3 buckets located in a specific region:
 
-We find all the .tif files and then convert and save them to /outputs/
+```bash
+%%bash --out job_id
+bacalhau docker run \
+    --wait \
+    --id-only \
+    --timeout 3600 \
+    --wait-timeout-secs 3600 \
+    -i src=s3://bdc-sentinel-2/s2-16d/v1/075/086/2018/02/18/*,dst=/bdc-sentinel-2/,opt=region=us-west-2  \
+    -i src=s3://sentinel-cogs/sentinel-s2-l2a-cogs/28/M/CV/2022/6/S2B_28MCV_20220620_0_L2A/*,dst=/sentinel-cogs/,opt=region=us-west-2 \
+    jsacex/gdal-s3
+```
 
+The job has been submitted and Bacalhau has printed out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
 
-The job has been submitted and Bacalhau has printed out the related job id. We store that in an environment variable so that we can reuse it later on.
+```python
+%env JOB_ID={job_id}
+```
 
-## Checking the State of your Jobs
+## 2. Checking the State of your Jobs
 
-- **Job status**: You can check the status of the job using `bacalhau list`.
+**Job status**: You can check the status of the job using `bacalhau list`.
 
 
 ```bash
@@ -78,7 +77,7 @@ bacalhau list --id-filter=${JOB_ID} --no-style
 
 When it says `Published` or `Completed`, that means the job is done, and we can get the results.
 
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
 
 
 ```bash
@@ -86,7 +85,7 @@ When it says `Published` or `Completed`, that means the job is done, and we can
 bacalhau describe ${JOB_ID}
 ```
 
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
 
 
 ```bash
@@ -95,11 +94,8 @@ rm -rf results && mkdir results # Temporary directory to store the results
 bacalhau get ${JOB_ID} --output-dir results # Download the results
 ```
 
-After the download has finished you should see the following contents in the results directory.
-
-## Viewing your Job Output
 
-To view the file, run the following command:
+## 3. Viewing your Job Output
 
 ### Display the image
 
@@ -136,6 +132,7 @@ for imageName in glob.glob('results/outputs/*.jpg'):
         display(img)
 
 ```
+The code processes and displays all images in the specified directory by applying cropping and resizing with a specified reduction factor. 
 
     results/outputs/S2-16D_V1_075086_20180218_B04_TCI.jpg
 
@@ -154,3 +151,5 @@ for imageName in glob.glob('results/outputs/*.jpg'):
 ![png](index_files/index_19_3.png)
     
 
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_1.png b/docs/docs/setting-up/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_1.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_1.png
rename to docs/docs/setting-up/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_1.png
diff --git a/docs/docs/examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_3.png b/docs/docs/setting-up/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_3.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_3.png
rename to docs/docs/setting-up/workload-onboarding/Reading-From-Multiple-S3-Buckets/index_files/index_19_3.png
diff --git a/docs/docs/setting-up/workload-onboarding/Running-Jupyter-Notebook/index.md b/docs/docs/setting-up/workload-onboarding/Running-Jupyter-Notebook/index.md
new file mode 100644
index 0000000000..e0d41ba142
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/Running-Jupyter-Notebook/index.md
@@ -0,0 +1,227 @@
+---
+sidebar_label: "Running-Jupyter-Notebook"
+sidebar_position: 3
+---
+# Running Jupyter Notebooks on Bacalhau
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/bacalhau-project/examples/blob/main/workload-onboarding/Running-Jupyter-Notebook/index.ipynb)
+[![Open In Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/bacalhau-project/examples/HEAD?labpath=workload-onboarding/Running-Jupyter-Notebook/index.ipynb)
+[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
+
+## Introduction
+Jupyter Notebooks have become an essential tool for data scientists, researchers, and developers for interactive computing and the development of data-driven projects. They provide an efficient way to share code, equations, visualizations, and narrative text with support for multiple programming languages. In this tutorial, we will introduce you to running Jupyter Notebooks on Bacalhau, a powerful and flexible container orchestration platform. By leveraging Bacalhau, you can execute Jupyter Notebooks in a scalable and efficient manner using Docker containers, without the need for manual setup or configuration.
+
+In the following sections, we will explore two examples of executing Jupyter Notebooks on Bacalhau:
+
+1. **Executing a Simple Hello World Notebook:** We will begin with a basic example to familiarize you with the process of running a Jupyter Notebook on Bacalhau. We will execute a simple "Hello, World!" notebook to demonstrate the steps required for running a notebook in a containerized environment.
+
+2. **Notebook to Train an MNIST Model:** In this section, we will dive into a more advanced example. We will execute a Jupyter Notebook that trains a machine-learning model on the popular MNIST dataset. This will showcase the potential of Bacalhau to handle more complex tasks while providing you with insights into utilizing containerized environments for your data science projects.
+
+### Prerequisite
+
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+
+
+## 1. Executing a Simple Hello World Notebook
+
+There are no external dependencies that we need to install. All dependencies are already there in the container.
+
+
+```bash
+%%bash --out job_id
+bacalhau docker run \
+    --wait \
+    --id-only \
+    --timeout 3600 \
+    --wait-timeout-secs 3600 \
+    -w /inputs \
+    -i https://raw.githubusercontent.com/js-ts/hello-notebook/main/hello.ipynb \
+    jsacex/jupyter \
+    -- jupyter nbconvert --execute --to notebook --output /outputs/hello_output.ipynb hello.ipynb
+```
+
+`/inputs/hello.ipynb`: This is the path of the input Jupyter Notebook inside the Docker container.
+
+`-i`: This flag stands for "input" and is used to provide the URL of the input Jupyter Notebook you want to execute.  
+
+`https://raw.githubusercontent.com/js-ts/hello-notebook/main/hello.ipynb`: This is the URL of the input Jupyter Notebook.  
+
+`jsacex/jupyter`: This is the name of the Docker image used for running the Jupyter Notebook. It is a minimal Jupyter Notebook stack based on the official Jupyter Docker Stacks.  
+
+`--`: This double dash is used to separate the Bacalhau command options from the command that will be executed inside the Docker container.  
+
+`jupyter nbconvert`: This is the primary command used to convert and execute Jupyter Notebooks. It allows for the conversion of notebooks to various formats, including execution.  
+
+`--execute`: This flag tells `nbconvert` to execute the notebook and store the results in the output file.  
+
+`--to notebook`: This option specifies the output format. In this case, we want to keep the output as a Jupyter Notebook.  
+
+`--output /outputs/hello_output.ipynb`: This option specifies the path and filename for the output Jupyter Notebook, which will contain the results of the executed input notebook.  
+
+
+
+## Checking the State of your Jobs
+
+**Job status**: You can check the status of the job using `bacalhau list`.
+
+
+```bash
+%%bash
+bacalhau list --id-filter=${JOB_ID} --no-style
+```
+
+When it says `Published` or `Completed`, that means the job is done, and we can get the results.
+
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
+
+
+```bash
+%%bash
+bacalhau describe ${JOB_ID}
+```
+
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
+
+
+```bash
+%%bash
+rm -rf results && mkdir results # Temporary directory to store the results
+bacalhau get ${JOB_ID} --output-dir results # Download the results
+```
+
+After the download has finished you can see the contents in the `results` directory, running the command below:
+
+```bash
+%%bash
+ls results/outputs
+
+hello_output.nbconvert.ipynb
+```
+
+## 2. Running Notebook to Train an MNIST Model
+
+### Building the container (optional)
+
+#### Prerequisite
+1. Install Docker on your local machine.  
+
+2. Sign up for a DockerHub account if you don't already have one.  
+
+**Step 1: Create a Dockerfile**  
+
+Create a new file named Dockerfile in your project directory with the following content:
+
+```Dockerfile
+# Use the official Python image as the base image
+FROM tensorflow/tensorflow:nightly-gpu
+
+# Set the working directory in the container
+WORKDIR /
+
+RUN apt-get update -y
+
+COPY mnist.ipynb .
+# Install the Python packages
+COPY requirements.txt .
+
+RUN python3 -m pip install --upgrade pip
+
+# Install the Python packages
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN pip install -U scikit-learn
+```
+This Dockerfile creates a Docker image based on the official `TensorFlow` GPU-enabled image, sets the working directory to the root, updates the package list, and copies an IPython notebook (`mnist.ipynb`) and a `requirements.txt` file. It then upgrades `pip` and installs Python packages from the `requirements.txt` file, along with `scikit-learn`. The resulting image provides an environment ready for running the `mnist.ipynb` notebook with `TensorFlow` and `scikit-learn`, as well as other specified dependencies.
+
+**Step 2: Build the Docker Image**  
+
+In your terminal, navigate to the directory containing the Dockerfile and run the following command to build the Docker image:
+
+```bash
+docker build -t your-dockerhub-username/jupyter-mnist-tensorflow:latest .
+```
+Replace "your-dockerhub-username" with your actual DockerHub username. This command will build the Docker image and tag it with your DockerHub username and the name "your-dockerhub-username/jupyter-mnist-tensorflow".
+
+**Step 3: Push the Docker Image to DockerHub**  
+
+Once the build process is complete, push the Docker image to DockerHub using the following command:
+
+```bash
+docker push your-dockerhub-username/jupyter-mnist-tensorflow
+```
+
+Again, replace "your-dockerhub-username" with your actual DockerHub username. This command will push the Docker image to your DockerHub repository.
+
+### Running the job on Bacalhau
+
+#### Prerequisite
+
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+
+
+```bash
+%%bash --out job_id
+bacalhau docker run \
+    --wait \
+    --id-only \
+    --timeout 3600 \
+    --wait-timeout-secs 3600 \
+    --gpu 1 \
+    -i gitlfs://huggingface.co/datasets/VedantPadwal/mnist.git \
+    jsacex/jupyter-tensorflow-mnist:v02 \
+    -- jupyter nbconvert --execute --to notebook --output /outputs/mnist_output.ipynb mnist.ipynb
+```
+
+### Structure of the command
+
+`--gpu 1`: Flag to specify the number of GPUs to use for the execution. In this case, 1 GPU will be used.  
+
+`-i gitlfs://huggingface.co/datasets/VedantPadwal/mnist.git`: The `-i` flag is used to clone the MNIST dataset from Hugging Face's repository using Git LFS. The files will be mounted inside the container.  
+
+`jsacex/jupyter-tensorflow-mnist:v02`: The name and the tag of the Docker image.  
+
+`--`: This double dash is used to separate the Bacalhau command options from the command that will be executed inside the Docker container.  
+
+`jupyter nbconvert --execute --to notebook --output /outputs/mnist_output.ipynb mnist.ipynb`: The command to be executed inside the container. In this case, it runs the `jupyter nbconvert` command to execute the `mnist.ipynb` notebook and save the output as `mnist_output.ipynb` in the `/outputs` directory.
+
+## Checking the State of your Jobs
+
+**Job status**: You can check the status of the job using `bacalhau list`.
+
+
+```bash
+%%bash
+bacalhau list --id-filter=${JOB_ID} --no-style
+```
+
+When it says `Published` or `Completed`, that means the job is done, and we can get the results.
+
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
+
+
+```bash
+%%bash
+bacalhau describe ${JOB_ID}
+```
+
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
+
+
+```bash
+%%bash
+rm -rf results && mkdir results # Temporary directory to store the results
+bacalhau get ${JOB_ID} --output-dir results # Download the results
+```
+
+After the download has finished you can see the contents in the `results` directory, running the command below:
+
+
+```bash
+%%bash
+ls results/outputs
+```
+
+The outputs include our trained model and the Jupyter notebook with the output cells.
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/setting-up/workload-onboarding/Sparkov-Data-Generation/index.md b/docs/docs/setting-up/workload-onboarding/Sparkov-Data-Generation/index.md
new file mode 100644
index 0000000000..4b8f67ab2e
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/Sparkov-Data-Generation/index.md
@@ -0,0 +1,213 @@
+---
+sidebar_label: "Sparkov Data Generation"
+sidebar_position: 11
+---
+# Generate Synthetic Data using Sparkov Data Generation technique
+
+
+## Introduction
+
+A synthetic dataset is generated by algorithms or simulations which has similar characteristics to real-world data. Collecting real-world data, especially data that contains sensitive user data like credit card information, is not possible due to security and privacy concerns. If a data scientist needs to train a model to detect credit fraud, they can use synthetically generated data instead of using real data without compromising the privacy of users.
+
+The advantage of using Bacalhau is that you can generate terabytes of synthetic data without having to install any dependencies or store the data locally.
+
+In this example, we will learn how to run Bacalhau on a synthetic dataset. We will generate synthetic credit card transaction data using the Sparkov program and store the results in IPFS.
+
+### Prerequisite
+
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+
+## 1. Running Sparkov Locally​
+
+To run Sparkov locally, you'll need to clone the repo and install dependencies:
+
+
+
+```bash
+%%bash
+git clone https://github.com/js-ts/Sparkov_Data_Generation/
+pip3 install -r Sparkov_Data_Generation/requirements.txt
+```
+
+Go to the `Sparkov_Data_Generation` directory:
+
+
+```python
+%cd Sparkov_Data_Generation
+```
+
+Create a temporary directory (`outputs`) to store the outputs:
+
+
+```bash
+%%bash
+mkdir ../outputs
+```
+
+## 2. Running the script
+
+```bash
+%%bash
+python3 datagen.py -n 1000 -o ../outputs "01-01-2022" "10-01-2022"
+```
+
+The command above executes the Python script `datagen.py`, passing the following arguments to it:
+
+`-n 1000`:  Number of customers to generate
+
+`-o ../outputs`: path to store the outputs
+
+`"01-01-2022"`: Start date
+
+`"10-01-2022"`: End date
+
+Thus, this command uses a Python script to generate synthetic credit card transaction data for the period from `01-01-2022` to `10-01-2022` and saves the results in the `../outputs` directory.
+
+
+To see the full list of options, use:
+
+
+```bash
+%%bash
+python datagen.py -h
+```
+
+## 3. Containerize Script using Docker
+
+To build your own docker container, create a `Dockerfile`, which contains instructions to build your image:
+
+
+```
+%%writefile Dockerfile
+
+FROM python:3.8
+
+RUN apt update && apt install git
+
+RUN git clone https://github.com/js-ts/Sparkov_Data_Generation/
+
+WORKDIR /Sparkov_Data_Generation/
+
+RUN pip3 install -r requirements.txt
+```
+
+These commands specify how the image will be built, and what extra requirements will be included. We use `python:3.8` as the base image, install `git`, clone the `Sparkov_Data_Generation` repository from GitHub, set the working directory inside the container to `/Sparkov_Data_Generation/`, and install Python dependencies listed in the `requirements.txt` file."
+
+:::info
+See more information on how to containerize your script/app [here](https://docs.docker.com/get-started/02_our_app/)
+:::
+
+
+### Build the container
+
+We will run `docker build` command to build the container:
+
+```
+docker build -t <hub-user>/<repo-name>:<tag> .
+```
+
+Before running the command replace:
+
+**`hub-user`** with your docker hub username. If you don’t have a docker hub account [follow these instructions to create docker account](https://docs.docker.com/docker-id/), and use the username of the account you created
+
+**`repo-name`** with the name of the container, you can name it anything you want
+
+**`tag`** this is not required but you can use the `latest` tag
+
+In our case:
+
+```
+docker build -t jsacex/sparkov-data-generation .
+```
+
+### Push the container
+
+Next, upload the image to the registry. This can be done by using the Docker hub username, repo name or tag.
+
+```
+docker push <hub-user>/<repo-name>:<tag>
+```
+
+In our case:
+
+```
+docker push jsacex/sparkov-data-generation
+```
+
+
+After the repo image has been pushed to Docker Hub, we can now use the container for running on Bacalhau
+
+## 4. Running a Bacalhau Job
+
+
+Now we're ready to run a Bacalhau job: 
+
+
+```bash
+%%bash --out job_id
+bacalhau docker run \
+    --id-only \
+    --wait \
+    jsacex/sparkov-data-generation \
+    --  python3 datagen.py -n 1000 -o ../outputs "01-01-2022" "10-01-2022"
+```
+
+### Structure of the command:
+
+`bacalhau docker run`: call to Bacalhau
+
+`jsacex/sparkov-data-generation`: the name of the docker image we are using
+
+`--  python3 datagen.py -n 1000 -o ../outputs "01-01-2022" "10-01-2022"`: the arguments passed into the container, specifying the execution of the Python script `datagen.py` with specific parameters, such as the amount of data, output path, and time range. 
+
+
+When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
+
+
+```python
+%env JOB_ID={job_id}
+```
+
+## 5. Checking the State of your Jobs
+
+**Job status**: You can check the status of the job using `bacalhau list`.
+
+
+```bash
+%%bash
+bacalhau list --id-filter ${JOB_ID}
+```
+
+When it says `Published` or `Completed`, that means the job is done, and we can get the results.
+
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
+
+
+
+```bash
+%%bash
+bacalhau describe ${JOB_ID}
+```
+
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
+
+
+```bash
+%%bash
+rm -rf results && mkdir -p results
+bacalhau get ${JOB_ID} --output-dir results
+```
+
+
+## 6. Viewing your Job Output
+
+To view the contents of the current directory, run the following command:
+
+
+```bash
+%%bash
+ls results/outputs  
+```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/setting-up/workload-onboarding/bacalhau-docker-image/index.md b/docs/docs/setting-up/workload-onboarding/bacalhau-docker-image/index.md
new file mode 100644
index 0000000000..1ede74a665
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/bacalhau-docker-image/index.md
@@ -0,0 +1,175 @@
+---
+sidebar_label: "Bacalhau Docker Image"
+sidebar_position: 1
+description: How to use the Bacalhau Docker image
+---
+# Bacalhau Docker Image
+
+This documentation explains how to use the Bacalhau Docker image to run tasks and manage them using the Bacalhau client.
+
+## Prerequisites
+
+To get started, you need to install the Bacalhau client (see more information [here](../../../getting-started/installation.md)) and Docker.
+
+## 1. Pull the Bacalhau Docker image
+
+The first step is to pull the Bacalhau Docker image from the [Github container registry](https://github.com/orgs/bacalhau-project/packages/container/package/bacalhau).
+
+```shell
+docker pull ghcr.io/bacalhau-project/bacalhau:latest
+
+Expected output:
+latest: Pulling from bacalhau-project/bacalhau
+d14ccdd25413: Pull complete
+621f190d05c8: Pull complete
+Digest: sha256:3cda5619984de9b56c738c50f94188684170f54f7e417f8dcbe74ff8ec8eb434
+Status: Downloaded newer image for ghcr.io/bacalhau-project/bacalhau:latest
+ghcr.io/bacalhau-project/bacalhau:latest
+```
+
+You can also pull a specific version of the image, e.g.:
+
+```bash
+docker pull ghcr.io/bacalhau-project/bacalhau:v0.3.16
+```
+
+:::warning
+Remember that the "latest" tag is just a string. It doesn't refer to the latest version of the Bacalhau client, it refers to an image that has the "latest" tag. Therefore, if your machine has already downloaded the "latest" image, it won't download it again. To force a download, you can use the `--no-cache` flag.
+:::
+
+## 2. Check version
+
+To check the version of the Bacalhau client, run:
+
+```shell
+docker run -t ghcr.io/bacalhau-project/bacalhau:latest version
+
+Expected Output:
+13:38:54.518 | INF pkg/repo/fs.go:81 > Initializing repo at '/root/.bacalhau' for environment 'production'
+CLIENT  SERVER  UPDATE MESSAGE
+v1.2.0  v1.2.0
+```
+
+## 3. Running a Bacalhau Job
+
+In the example below, an Ubuntu-based job runs to print the message 'Hello from Docker Bacalhau: 
+
+```shell
+docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
+    docker run \
+        --id-only \
+        --wait \
+        ubuntu:latest \
+        -- sh -c 'uname -a && echo "Hello from Docker Bacalhau!"'
+```
+
+
+### Structure of the command
+
+`ghcr.io/bacalhau-project/bacalhau:latest `: Name of the Bacalhau Docker image
+
+`--id-only`: Output only the job id
+
+`--wait`: Wait for the job to finish
+
+`ubuntu:latest.` Ubuntu container
+
+ `--`: Separate Bacalhau parameters from the command to be executed inside the container
+
+ `sh -c 'uname -a && echo "Hello from Docker Bacalhau!"'`: The command executed inside the container 
+
+Let's have a look at the command execution in the terminal:
+
+```shell
+13:53:46.478 | INF pkg/repo/fs.go:81 > Initializing repo at '/root/.bacalhau' for environment 'production'
+ab95a5cc-e6b7-40f1-957d-596b02251a66
+```
+
+The output you're seeing is in two parts:  
+**The first line:** `13:53:46.478 | INF pkg/repo/fs.go:81 > Initializing repo at '/root/.bacalhau' for environment 'production'` is an informational message indicating the initialization of a repository at the specified directory `('/root/.bacalhau')` for the `production` environment.  
+**The second line:** `ab95a5cc-e6b7-40f1-957d-596b02251a66` is a `job ID`, which represents the result of executing a command inside a Docker container. It can be used to obtain additional information about the executed job or to access the job's results. We store that in an environment variable so that we can reuse it later on (env: `JOB_ID=ab95a5cc-e6b7-40f1-957d-596b02251a66`)
+
+To print out the **content of the Job ID**, run the following command:
+
+```shell
+docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
+    describe ab95a5cc-e6b7-40f1-957d-596b02251a66 \
+        | grep -A 2 "stdout: |"
+
+Expected Output:
+stdout: |
+        Linux fff680719453 6.2.0-1019-gcp #21~22.04.1-Ubuntu SMP Thu Nov 16 18:18:34 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux
+        Hello from Docker Bacalhau!
+```
+
+## 4. Submit a Job With Output Files
+
+One inconvenience that you'll see is that you'll need to mount directories into the container to access files. This is because the container is running in a separate environment from your host machine. Let's take a look at the example below:
+
+The first part of the example should look familiar, except for the Docker commands.
+
+
+```shell
+docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
+    docker run \
+        --id-only \
+        --wait \
+        --gpu 1 \
+        ghcr.io/bacalhau-project/examples/stable-diffusion-gpu:0.0.1 -- \
+            python main.py --o ./outputs --p "A Docker whale and a cod having a conversation about the state of the ocean"
+```
+
+When a job is submitted, Bacalhau prints out the related `job_id` (`a46a9aa9-63ef-486a-a2f8-6457d7bafd2e`):
+
+```shell
+09:05:58.434 | INF pkg/repo/fs.go:81 > Initializing repo at '/root/.bacalhau' for environment 'production'
+a46a9aa9-63ef-486a-a2f8-6457d7bafd2e
+```
+
+
+## 5. Checking the State of your Jobs
+
+**Job status**: You can check the status of the job using `bacalhau list`.
+
+
+```bash
+%%bash
+docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
+    list $JOB_ID \
+```
+
+When it says `Completed`, that means the job is done, and we can get the results.
+
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
+
+
+```bash
+%%bash
+docker run -t ghcr.io/bacalhau-project/bacalhau:latest \
+    describe $JOB_ID \
+
+```
+
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in the `result` directory.
+
+
+```bash
+%%bash
+bacalhau get ${JOB_ID} --output-dir result
+```
+
+After the download has finished you should see the following contents in the results directory.
+
+
+
+
+
+![png](index_files/index_25_0.png)
+
+
+
+
+## Support
+
+If have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
+
diff --git a/docs/docs/examples/workload-onboarding/bacalhau-docker-image/index_files/index_25_0.png b/docs/docs/setting-up/workload-onboarding/bacalhau-docker-image/index_files/index_25_0.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/bacalhau-docker-image/index_files/index_25_0.png
rename to docs/docs/setting-up/workload-onboarding/bacalhau-docker-image/index_files/index_25_0.png
diff --git a/docs/docs/examples/workload-onboarding/custom-containers/index.md b/docs/docs/setting-up/workload-onboarding/custom-containers/index.md
similarity index 50%
rename from docs/docs/examples/workload-onboarding/custom-containers/index.md
rename to docs/docs/setting-up/workload-onboarding/custom-containers/index.md
index 70f4a63ae1..0c614e48c3 100644
--- a/docs/docs/examples/workload-onboarding/custom-containers/index.md
+++ b/docs/docs/setting-up/workload-onboarding/custom-containers/index.md
@@ -9,18 +9,16 @@ sidebar_position: 11
 
 Bacalhau operates by executing jobs within containers. This example shows you how to build and use a custom docker container.
 
-## TD;LR
-Running Custom Containers in Bacalhau
+### Prerequisite
 
-## Prerequisite
+1. To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+2. This example requires Docker. If you don't have Docker installed, you can install it from [here](https://docs.docker.com/install/). Docker commands will not work on hosted notebooks like Google Colab, but the Bacalhau commands will.
 
-- To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-- This example requires Docker. If you don't have Docker installed, you can install it from [here](https://docs.docker.com/install/). Docker commands will not work on hosted notebooks like Google Colab, but the Bacalhau commands will.
 
+##  1. Running Containers
 
-##  Running Containers in Bacalhau
-
-You're probably used to running docker commands to run a container.
+### Docker Command
+You're likely familiar with executing Docker commands to start a container:
 
 
 ```bash
@@ -28,23 +26,50 @@ You're probably used to running docker commands to run a container.
 docker run docker/whalesay cowsay sup old fashioned container run
 ```
 
-Bacalhau uses a syntax that is similar to docker and you can use the same containers. The main difference is that input and output data is passed to the container via IPFS, to enable planetary scale. In this example, it doesn't make too much difference except that we need to download the stdout.
-
-The `--wait` flag tells Bacalhau to wait for the job to finish before returning. This is useful in interactive sessions like this, but you would normally allow jobs to complete in the background and use the `list` command to check on their status.
-
-Another difference is that by default Bacalhau overwrites the default entry point for the container so you have to pass all shell commands as arguments to the `run` command after the `--` flag.
-
-### Running a Bacalhau Job
+This command runs a container from the `docker/whalesay` image.
+The container executes the `cowsay sup old fashioned container run` command:
+
+```shell
+Expected output:
+_________________________________
+< sup old fashioned container run >
+ ---------------------------------
+    \
+     \
+      \
+                    ##        .
+              ## ## ##       ==
+           ## ## ## ##      ===
+       /""""""""""""""""___/ ===
+  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
+       \______ o          __/
+        \    \        __/
+          \____\______/
+```
 
+### Bacalhau Command
 
 ```bash
 %%bash --out job_id
 bacalhau docker run --wait --id-only docker/whalesay -- bash -c 'cowsay hello web3 uber-run'
 ```
 
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
+This command also runs a container from the `docker/whalesay` image, using Bacalhau. We use the `bacalhau docker run` command to start a job in a Docker container.
+It contains additional flags such as `--wait` to wait for job completion and `--id-only` to return only the job identifier.
+Inside the container, the `bash -c 'cowsay hello web3 uber-run'` command is executed.
+
+When a job is submitted, Bacalhau prints out the related `job_id` (`7e41b9b9-a9e2-4866-9fce-17020d8ec9e0`):
+
+```shell
+7e41b9b9-a9e2-4866-9fce-17020d8ec9e0
+```
+We store that in an environment variable so that we can reuse it later on.
 
-You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
+```python
+%env JOB_ID={job_id}
+```
+
+You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
 
 
 ```bash
@@ -59,13 +84,42 @@ Viewing your job output
 ```bash
 %%bash
 cat ./results/stdout
+
+Expected output:
+
+ _____________________
+< hello web3 uber-run >
+ ---------------------
+    \
+     \
+      \
+                    ##        .
+              ## ## ##       ==
+           ## ## ## ##      ===
+       /""""""""""""""""___/ ===
+  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
+       \______ o          __/
+        \    \        __/
+          \____\______/
 ```
 
-## Building Your Own Custom Container For Bacalhau
+Both commands execute cowsay in the `docker/whalesay` container, but Bacalhau provides additional features for working with jobs at scale.
+
+### Bacalhau Syntax
+Bacalhau uses a syntax that is similar to Docker, and you can use the same containers. The main difference is that input and output data is passed to the container via IPFS, to enable planetary scale. In the example above, it doesn't make too much difference except that we need to download the stdout.
+
+The `--wait` flag tells Bacalhau to wait for the job to finish before returning. This is useful in interactive sessions like this, but you would normally allow jobs to complete in the background and use the `bacalhau list` command to check on their status.
+
+Another difference is that by default Bacalhau overwrites the default entry point for the container, so you have to pass all shell commands as arguments to the `run` command after the `--` flag.
+
+
+
+
+## 2. Building Your Own Custom Container For Bacalhau
 
 To use your own custom container, you must publish the container to a container registry that is accessible from the Bacalhau network. At this time, only public container registries are supported.
 
-To demonstrate this, you will develop and build a simple custom container that comes from an old docker example. I remember seeing cowsay at a Docker conference about a decade ago. I think it's about time we brought it back to life and distribute it across the Bacalhau network.
+To demonstrate this, you will develop and build a simple custom container that comes from an old Docker example. I remember seeing cowsay at a Docker conference about a decade ago. I think it's about time we brought it back to life and distribute it across the Bacalhau network.
 
 
 ```python
@@ -118,7 +172,7 @@ docker build -t ghcr.io/bacalhau-project/examples/codsay:latest . 2> /dev/null
 docker run --rm ghcr.io/bacalhau-project/examples/codsay:latest codsay I like swimming in data
 ```
 
-Once your container is working as expected then you should push it to a public container registry. In this example, I'm pushing to Github's container registry, but we'll skip the step below because you probably don't have permission.Remember that the Bacalhau nodes expect your container to have a `linux/amd64` architecture.
+Once your container is working as expected then you should push it to a public container registry. In this example, I'm pushing to Github's container registry, but we'll skip the step below because you probably don't have permission. Remember that the Bacalhau nodes expect your container to have a `linux/amd64` architecture.
 
 
 ```bash
@@ -126,7 +180,7 @@ Once your container is working as expected then you should push it to a public c
 # docker buildx build --platform linux/amd64,linux/arm64 --push -t ghcr.io/bacalhau-project/examples/codsay:latest .
 ```
 
-##  Running Your Custom Container on Bacalhau
+## 3. Running Your Custom Container on Bacalhau
 
 Now we're ready to submit a Bacalhau job using your custom container. This code runs a job, downloads the results, and prints the stdout.
 
@@ -161,4 +215,29 @@ View your job output
 ```bash
 %%bash
 cat ./results/stdout
+
+Expected output:
+
+_______________________
+< Look at all this data >
+ -----------------------
+   \
+    \
+                               ,,,,_
+                            ┌Φ▓╬▓╬▓▓▓W      @▓▓▒,
+                           ╠▓╬▓╬╣╬╬▓╬▓▓   ╔╣╬╬▓╬╣▓,
+                    __,┌╓═╠╬╠╬╬╬Ñ╬╬╬Ñ╬╬¼,╣╬╬▓╬╬▓╬▓▓▓┐        ╔W_             ,φ▓▓
+               ,«@▒╠╠╠╠╩╚╙╙╩Ü╚╚╚╚╩╙╙╚╠╩╚╚╟▓▒╠╠╫╣╬╬╫╬╣▓,   _φ╬▓╬╬▓,        ,φ╣▓▓╬╬
+          _,φÆ╩╬╩╙╚╩░╙╙░░╩`=░╙╚»»╦░=╓╙Ü1R░│░╚Ü░╙╙╚╠╠╠╣╣╬≡Φ╬▀╬╣╬╬▓▓▓_   ╓▄▓▓▓▓▓▓╬▌
+      _,φ╬Ñ╩▌▐█[▒░░░░R░░▀░`,_`!R`````╙`-'╚Ü░░Ü░░░░░░░│││░╚╚╙╚╩╩╩╣Ñ╩╠▒▒╩╩▀▓▓╣▓▓╬╠▌
+     '╚╩Ü╙│░░╙Ö▒Ü░░░H░░R ▒¥╣╣@@@▓▓▓  := '`   `░``````````````````````````]▓▓▓╬╬╠H
+       '¬═▄ `░╙Ü░╠DjK` Å»»╙╣▓▓▓▓╬Ñ     -»`       -`      `  ,;╓▄╔╗∞  ~▓▓▓▀▓▓╬╬╬▌
+             '^^^`   _╒Γ   `╙▀▓▓╨                     _, ⁿD╣▓╬╣▓╬▓╜      ╙╬▓▓╬╬▓▓
+                 ```└                           _╓▄@▓▓▓╜   `╝╬▓▓╙           ²╣╬▓▓
+                        %φ▄╓_             ~#▓╠▓▒╬▓╬▓▓^        `                ╙╙
+                         `╣▓▓▓              ╠╬▓╬▓╬▀`
+                           ╚▓▌               '╨▀╜
 ```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/setting-up/workload-onboarding/docker-workload-onboarding.md b/docs/docs/setting-up/workload-onboarding/docker-workload-onboarding.md
new file mode 100644
index 0000000000..79446f5f31
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/docker-workload-onboarding.md
@@ -0,0 +1,267 @@
+---
+sidebar_label: 'Workloads (Docker)'
+sidebar_position: 3
+description: How to use docker containers with Bacalhau
+---
+import ReactPlayer from 'react-player'
+
+# Docker Workloads
+
+Bacalhau executes jobs by running them within containers. Bacalhau employs a syntax closely resembling Docker, allowing you to utilize the same containers. The key distinction lies in how input and output data are transmitted to the container via IPFS, enabling scalability on a global level.
+
+This section describes how to migrate a workload based on a Docker container into a format that will work with the Bacalhau client.
+
+:::info
+
+You can check out this example tutorial on [how to work with custom containers in Bacalhau](../workload-onboarding/custom-containers/index.md) to see how we used all these steps together.
+
+:::
+
+## Requirements
+Here are few things to note before getting started:
+
+1. **Container Registry**: Ensure that the container is published to a public container registry that is accessible from the Bacalhau network.
+2. **Architecture Compatibility**: Bacalhau supports only images that match the host node's architecture. Typically, most nodes run on `linux/amd64`, so containers in `arm64` format are not able to run.
+3. **Input Flags**:  
+The `--input ipfs://...` flag supports only **directories** and does not support CID subpaths.  
+The `--input https://...` flag supports only **single files** and does not support URL directories.  
+The `--input s3://...` flag supports S3 keys and prefixes. For example, `s3://bucket/logs-2023-04*` includes all logs for April 2023.
+
+
+:::info
+
+You can check to see a [list of example public containers](https://github.com/orgs/bacalhau-project/packages?repo_name=examples) used by the Bacalhau team
+
+**Note**: Only about a third of examples have their containers here. The rest are under random docker hub registries (mostly Vedants).
+
+:::
+
+## Runtime Restrictions
+
+To help provide a safe, secure network for all users, we add the following runtime restrictions:
+
+1. **Limited Ingress/Egress Networking**:
+
+All ingress/egress networking is limited as described in the [networking](../networking-instructions/fundamentals.md) documentation.
+You won't be able to pull `data/code/weights/` etc. from an external source.
+
+2. **Data Passing with Docker Volumes**:
+
+A job includes the concept of input and output volumes, and the Docker executor implements support for these. This means you can specify your CIDs, URLs, and/or S3 objects as `input` paths and also write results to an `output` volume. This can be seen in the following example:
+
+```shell
+bacalhau docker run \
+  -i s3://mybucket/logs-2023-04*:/input \
+  -o apples:/output_folder \
+  ubuntu \
+  bash -c 'ls /input > /output_folder/file.txt'
+```
+The above example demonstrates an input volume flag `-i s3://mybucket/logs-2023-04*`, which mounts all S3 objects in bucket `mybucket` with `logs-2023-04` prefix within the docker container at location `/input` (root).
+
+Output volumes are mounted to the Docker container at the location specified. In the example above, any content written to `/output_folder` will be made available within the `apples` folder in the job results CID.
+
+Once the job has run on the executor, the contents of `stdout` and `stderr` will be added to any named output volumes the job has used (in this case `apples`), and all those entities will be packaged into the results folder which is then published to a remote location by the publisher.
+
+
+## Onboarding Your Workload
+
+### Step 1 - Read Data From Your Directory
+
+If you need to pass data into your container you will do this through a Docker volume. You'll need to modify your code to read from a local directory.
+
+We make the assumption that you are reading from a directory called `/inputs`, which is set as the default.
+
+:::info
+
+You can specify which directory the data is written to with the [`--input`](../../dev/cli-reference/all-flags.md#docker-run) CLI flag.
+
+:::
+
+### Step 2 - Write Data to the Your Directory
+
+If you need to return data from your container you will do this through a Docker volume. You'll need to modify your code to write to a local directory.
+
+We make the assumption that you are writing to a directory called `/outputs`, which is set as the default.
+
+:::info
+
+You can specify which directory the data is written to with the [`--output-volumes`](../../dev/cli-reference/all-flags.md#docker-run) CLI flag.
+
+:::
+
+### Step 3 - Build and Push Your Image To a Registry
+
+At this step, you create (or update) a Docker image that Bacalhau will use to perform your task. You [build your image](https://docs.docker.com/engine/reference/commandline/build/) from your code and dependencies, then [push it](https://docs.docker.com/engine/reference/commandline/push/) to a public registry so that Bacalhau can access it. This is necessary for other Bacalhau nodes to run your container and execute the given task.
+
+:::caution
+
+Most Bacalhau nodes are of an `x86_64` architecture, therefore containers should be built for [`x86_64` systems](#what-containers-to-use).
+
+:::
+
+For example:
+
+```shell
+$ export IMAGE=myuser/myimage:latest
+$ docker build -t ${IMAGE} .
+$ docker image push ${IMAGE}
+```
+
+
+### Step 4 - Test Your Container
+
+To test your docker image locally, you'll need to execute the following command, changing the environment variables as necessary:
+
+```shell
+$ export LOCAL_INPUT_DIR=$PWD
+$ export LOCAL_OUTPUT_DIR=$PWD
+$ export CMD=(sh -c 'ls /inputs; echo do something useful > /outputs/stdout')
+$ docker run --rm \
+  -v ${LOCAL_INPUT_DIR}:/inputs  \
+  -v ${LOCAL_OUTPUT_DIR}:/outputs \
+  ${IMAGE} \
+  ${CMD}
+```
+Let's see what each command will be used for:
+
+```shell
+$ export LOCAL_INPUT_DIR=$PWD
+Exports the current working directory of the host system to the LOCAL_INPUT_DIR variable. This variable will be used for binding a volume and transferring data into the container.
+
+$ export LOCAL_OUTPUT_DIR=$PWD
+Exports the current working directory of the host system to the LOCAL_OUTPUT_DIR variable. Similarly, this variable will be used for binding a volume and transferring data from the container.
+
+$ export CMD=(sh -c 'ls /inputs; echo do something useful > /outputs/stdout')
+Creates an array of commands CMD that will be executed inside the container. In this case, it is a simple command executing 'ls' in the /inputs directory and writing text to the /outputs/stdout file.
+
+$ docker run ... ${IMAGE} ${CMD}
+Launches a Docker container using the specified variables and commands. It binds volumes to facilitate data exchange between the host and the container.
+```
+
+:::info
+
+Bacalhau will use the [default ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint) if your image contains one. If you need to specify another entrypoint, use the `--entrypoint` flag to `bacalhau docker run`.
+
+:::
+
+For example:
+
+```shell
+$ export LOCAL_INPUT_DIR=$PWD
+$ export LOCAL_OUTPUT_DIR=$PWD
+$ export CMD=(sh -c 'ls /inputs; echo "do something useful" > /outputs/stdout')
+$ export IMAGE=ubuntu
+$ docker run --rm \
+  -v ${LOCAL_INPUT_DIR}:/inputs  \
+  -v ${LOCAL_OUTPUT_DIR}:/outputs \
+  ${IMAGE} \
+  ${CMD}
+$ cat stdout
+```
+
+The result of the commands' execution is shown below:
+
+```shell
+do something useful
+```
+
+### Step 5 - Upload the Input Data
+
+Data is identified by its content identifier (CID) and can be accessed by anyone who knows the CID. You can use either of these methods to upload your data:
+
+[Copy data from a URL to public storage](../data-ingestion/from-url.md)  
+[Pin Data to public storage](../data-ingestion/pin.md)  
+[Copy Data from S3 Bucket to public storage](../data-ingestion/s3.md)  
+
+:::info
+You can mount your data anywhere on your machine, and Bacalhau will be able to run against that data
+:::
+
+### Step 6 - Run the Workload on Bacalhau
+
+To launch your workload in a Docker container, using the specified image and working with `input` data specified via IPFS CID, run the following command:
+
+```shell
+$ bacalhau docker run --input ipfs://${CID} ${IMAGE} ${CMD}
+```
+
+To check the status of your job, run the following command:
+
+```shell
+$ bacalhau list --id-filter JOB_ID
+```
+
+To get more information on your job,run:
+
+```shell
+$ bacalhau describe JOB_ID
+```
+
+To download your job, run:
+
+```shell
+$ bacalhau get JOB_ID
+```
+
+For example, running:
+
+```shell
+JOB_ID=$(bacalhau docker run ubuntu echo hello | grep 'Job ID:' | sed 's/.*Job ID: \([^ ]*\).*/\1/')
+echo "The job ID is: $JOB_ID"
+bacalhau list --id-filter $JOB_ID
+sleep 5
+bacalhau list --id-filter $JOB_ID
+bacalhau get $JOB_ID
+ls shards
+```
+
+outputs:
+
+```shell
+CREATED   ID        JOB                      STATE      VERIFIED  PUBLISHED 
+ 10:26:00  24440f0d  Docker ubuntu echo h...  Verifying                      
+ CREATED   ID        JOB                      STATE      VERIFIED  PUBLISHED               
+ 10:26:00  24440f0d  Docker ubuntu echo h...  Published            /ipfs/bafybeiflj3kha... 
+11:26:09.107 | INF bacalhau/get.go:67 > Fetching results of job '24440f0d-3c06-46af-9adf-cb524aa43961'...
+11:26:10.528 | INF ipfs/downloader.go:115 > Found 1 result shards, downloading to temporary folder.
+11:26:13.144 | INF ipfs/downloader.go:195 > Combining shard from output volume 'outputs' to final location: '/Users/phil/source/filecoin-project/docs.bacalhau.org'
+job-24440f0d-3c06-46af-9adf-cb524aa43961-shard-0-host-QmYgxZiySj3MRkwLSL4X2MF5F9f2PMhAE3LV49XkfNL1o3
+```
+
+:::caution
+The `--input` flag does not support CID subpaths for `ipfs://` content.
+:::
+
+Alternatively, you can run your workload with a publicly accessible http(s) URL, which will download the data temporarily into your public storage:
+
+```shell
+$ export URL=https://download.geofabrik.de/antarctica-latest.osm.pbf
+$ bacalhau docker run --input ${URL} ${IMAGE} ${CMD}
+
+$ bacalhau list 
+
+$ bacalhau get JOB_ID
+```
+
+:::caution
+The `--input` flag does not support URL directories.
+:::
+
+
+<!-- <ReactPlayer playing controls url='https://www.youtube.com/watch?v=t2AHD8yJhLY' playing='false'/> -->
+
+## Troubleshooting
+If you run into this compute error while running your docker image
+
+```
+Creating job for submission ... done ✅
+Finding node(s) for the job ... done ✅
+Node accepted the job ... done ✅
+Error while executing the job.
+```
+
+This can often be resolved by re-tagging your docker image
+
+## Support
+
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel)
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/index.md b/docs/docs/setting-up/workload-onboarding/index.md
similarity index 89%
rename from docs/docs/examples/workload-onboarding/index.md
rename to docs/docs/setting-up/workload-onboarding/index.md
index 40a904bec6..473af22bbc 100644
--- a/docs/docs/examples/workload-onboarding/index.md
+++ b/docs/docs/setting-up/workload-onboarding/index.md
@@ -1,6 +1,6 @@
 ---
 sidebar_label: "Workload Onboarding"
-sidebar_position: 1
+sidebar_position: 0
 ---
 # How To Work With Bacalhau
 
diff --git a/docs/docs/examples/workload-onboarding/python-pandas/index.md b/docs/docs/setting-up/workload-onboarding/python-pandas/index.md
similarity index 59%
rename from docs/docs/examples/workload-onboarding/python-pandas/index.md
rename to docs/docs/setting-up/workload-onboarding/python-pandas/index.md
index 50750f91ab..68ecae703e 100644
--- a/docs/docs/examples/workload-onboarding/python-pandas/index.md
+++ b/docs/docs/setting-up/workload-onboarding/python-pandas/index.md
@@ -7,21 +7,23 @@ sidebar_position: 6
 
 [![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
 
-### Introduction
+## Introduction
 
-Pandas is a Python package that provides fast, flexible, and expressive data structures designed to make working with data both easy and intuitive. It aims to be the fundamental high-level building block for doing practical, real-world data analysis in Python. Additionally, it has the broader goal of becoming the most powerful and flexible open-source data analysis/manipulation tool available in any language. It is already well on its way towards this goal.
+Pandas is a Python package that provides fast, flexible, and expressive data structures designed to make working with data both easy and intuitive. It aims to be the fundamental high-level building block for doing practical, real-world data analysis in Python. Additionally, it has the broader goal of becoming the most powerful and flexible open-source data analysis/manipulation tool available in any language. It is already well on its way towards this goal.  
+
+In this tutorial example, we will run Pandas script on Bacalhau.
 
-## TD;LR
-Running pandas script in Bacalhau
 
 ## Prerequisite
 
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+
 
+## 1. Running Pandas Locally
 
-## Running Pandas Locally
+To run the Pandas script on Bacalhau for analysis, first, we will place the Pandas script in a container and then run it at scale on Bacalhau.  
 
-To run the Pandas script on Bacalhau for analysis, first, we will place the Pandas script in a container and then run it at scale on Bacalhau. To get started, you need to install the Pandas library from pip.
+To get started, you need to install the Pandas library from pip:
 
 
 ```bash
@@ -42,13 +44,16 @@ import pandas as pd
 print(pd.read_csv("transactions.csv"))
 ```
 
+The overall purpose of the command above is to read data from a CSV file (`transactions.csv`) using Pandas and print the resulting DataFrame.  
+
+To download the `transactions.csv` file, run:
 
 ```bash
 %%bash
-# Downloading the dataset
 wget https://cloudflare-ipfs.com/ipfs/QmfKJT13h5k1b23ja3ZCVg5nFL9oKz2bVXc8oXgtwiwhjz/transactions.csv
 ```
 
+To output a content of the `transactions.csv` file, run:
 
 ```bash
 %%bash
@@ -65,20 +70,17 @@ Now let's run the script to read in the CSV file. The output will be a DataFrame
 python3 read_csv.py
 ```
 
-## Ingesting data
+## 2. Ingesting data
 
-To run pandas on Bacalhau you must store your assets in a location that Bacalhau has access to. We usually default to storing data on IPFS and code in a container, but you can also easily upload your script to IPFS too.
+To run Pandas on Bacalhau you must store your assets in a location that Bacalhau has access to. We usually default to storing data on IPFS and code in a container, but you can also easily upload your script to IPFS too.
 
-If you are interested in finding out more about how to ingest your data into IPFS, please see the [data ingestion guide](https://docs.bacalhau.org/examples/data-ingestion/).
+If you are interested in finding out more about how to ingest your data into IPFS, please see the [data ingestion guide](../../../setting-up/data-ingestion/).
 
-We've already uploaded the script and data to IPFS to the following CID: `QmfKJT13h5k1b23ja3ZCVg5nFL9oKz2bVXc8oXgtwiwhjz`. You can look at this by browsing to one of the HTTP IPFS proxies like [ipfs.io](https://cloudflare-ipfs.com/ipfs/QmfKJT13h5k1b23ja3ZCVg5nFL9oKz2bVXc8oXgtwiwhjz/) or [w3s.link](https://bafybeih4hyydvojazlyv5zseelgn5u67iq2wbrbk2q4xoiw2d3cacdmzlu.ipfs.w3s.link/).
+We've already uploaded the script and data to IPFS to the following CID: `QmfKJT13h5k1b23ja3ZCVg5nFL9oKz2bVXc8oXgtwiwhjz`. You can look at this by browsing to one of the HTTP IPFS proxies like [ipfs.io](https://cloudflare-ipfs.com/ipfs/QmfKJT13h5k1b23ja3ZCVg5nFL9oKz2bVXc8oXgtwiwhjz/) or [w3s.link](https://github.com/web3-storage/w3link).
 
-## Running a Bacalhau Job
-
-After mounting the Pandas script and data from IPFS, we can now use the container for running on Bacalhau. To submit a job, run the following Bacalhau command:
-
-Now we're ready to run a Bacalhau job, whilst mounting the Pandas script and data from IPFS. We'll use the `bacalhau docker run` command to do this. The `-v` flag allows us to mount a file or directory from IPFS into the container. The `-v` flag takes two arguments, the first is the IPFS CID and the second is the path to the directory in the container. The `-v` flag can be used multiple times to mount multiple directories.
+## 3. Running a Bacalhau Job
 
+Now we're ready to run a Bacalhau job, whilst mounting the Pandas script and data from IPFS. We'll use the `bacalhau docker run` command to do this:
 
 ```bash
 %%bash --out job_id
@@ -93,21 +95,25 @@ bacalhau docker run \
 
 ### Structure of the command
 
-- `bacalhau docker run`: call to bacalhau
+`bacalhau docker run`: call to Bacalhau
 
-- `amancevice/pandas `: Using the official pytorch Docker image
+`amancevice/pandas `: Docker image with pandas installed.
 
-- ``-i ipfs://QmfKJT13h5k1b23ja3Z .....`: Mounting the uploaded dataset to path
+`-i ipfs://QmfKJT13h5k1b23ja3ZCVg5nFL9oKz2bVXc8oXgtwiwhjz:/files`: Mounting the uploaded dataset to path. The `-i` flag allows us to mount a file or directory from IPFS into the container. It takes two arguments, the first is the IPFS CID (`QmfKJT13h5k1b23ja3ZCVg5nFL9oKz2bVXc8oXgtwiwhjz`) and the second is the file path within IPFS (`/files`). The `-i` flag can be used multiple times to mount multiple directories.
 
-- `-w /files` Our working directory is /outputs. This is the folder where we will save the model as it will automatically get uploaded to IPFS as outputs
+`-w /files` Our working directory is /files. This is the folder where we will save the model as it will automatically get uploaded to IPFS as outputs
 
 ` python read_csv.py`: python script to read pandas script
 
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
+When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
+
+```python
+%env JOB_ID={job_id}
+```
 
-## Checking the State of your Jobs
+## 4. Checking the State of your Jobs
 
-- **Job status**: You can check the status of the job using `bacalhau list`.
+**Job status**: You can check the status of the job using `bacalhau list`.
 
 
 ```bash
@@ -115,9 +121,9 @@ When a job is submitted, Bacalhau prints out the related `job_id`. We store that
 bacalhau list --id-filter ${JOB_ID}
 ```
 
-When it says `Completed`, that means the job is done, and we can get the results.
+When it says `Published` or `Completed`, that means the job is done, and we can get the results.
 
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
 
 
 ```bash
@@ -125,9 +131,7 @@ When it says `Completed`, that means the job is done, and we can get the results
 bacalhau describe ${JOB_ID}
 ```
 
-When it says `Published` or `Completed`, that means the job is done, and we can get the results.
-
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
 
 
 ```bash
@@ -136,12 +140,15 @@ rm -rf results && mkdir -p results
 bacalhau get ${JOB_ID}  --output-dir results
 ```
 
-## Viewing your Job Output
+## 5. Viewing your Job Output
 
 To view the file, run the following command:
 
 
 ```bash
 %%bash
-cat results/stdout # displays the contents of the file
+cat results/stdout 
 ```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/python-script/index.md b/docs/docs/setting-up/workload-onboarding/python-script/index.md
similarity index 74%
rename from docs/docs/examples/workload-onboarding/python-script/index.md
rename to docs/docs/setting-up/workload-onboarding/python-script/index.md
index 1955e5ec9b..a9521b1ae6 100644
--- a/docs/docs/examples/workload-onboarding/python-script/index.md
+++ b/docs/docs/setting-up/workload-onboarding/python-script/index.md
@@ -1,24 +1,17 @@
 # Scripting Bacalhau with Python
 
-
-[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
-
 Bacalhau allows you to easily execute batch jobs via the CLI. But sometimes you need to do more than that. You might need to execute a script that requires user input, or you might need to execute a script that requires a lot of parameters. In any case, you probably want to execute your jobs in a repeatable manner.
 
 This example demonstrates a simple Python script that is able to orchestrate the execution of lots of jobs in a repeatable manner.
 
-## TD;LR
-Running Python script in Bacalhau
-
-## Prerequisite
+### Prerequisite
 
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
 
 
 ## Executing Bacalhau Jobs with Python Scripts
 
-To demonstrate this example, I will use the data generated from the [ethereum analysis example](../../data-engineering/blockchain-etl/index.md). This produced a list of hashes that I will iterate over and execute a job for each one.
-
+To demonstrate this example, I will use the data generated from an Ethereum example. This produced a list of hashes that I will iterate over and execute a job for each one.
 
 ```python
 %%writefile hashes.txt
@@ -30,8 +23,7 @@ bafybeih6te26iwf5kzzby2wqp67m7a5pmwilwzaciii3zipvhy64utikre
 bafybeicjd4545xph6rcyoc74wvzxyaz2vftapap64iqsp5ky6nz3f5yndm
 ```
 
-Now let's run the following script. You can execute this script anywhere with `python bacalhau.py`.
-
+Now let's create a file called `bacalhau.py`. The script below automates the submission, monitoring, and retrieval of results for multiple Bacalhau jobs in parallel. It is designed to be used in a scenario where there are multiple hash files, each representing a job, and the script manages the execution of these jobs using Bacalhau commands.
 
 ```python
 %%writefile bacalhau.py
@@ -165,9 +157,9 @@ if __name__ == "__main__":
 ```
 
 This code has a few interesting features:
-* Change the value in the `main` call to change the number of jobs to execute
-* Because all jobs are complete at different times, there's a loop to check that all jobs have been completed before downloading the results -- if you don't do this you'll likely see an error when trying to download the results
-* When downloading the results, the IPFS get often times out, so I wrapped that in a loop
+1. Change the value in the `main` call (`main("hashes.txt", 10)`) to change the number of jobs to execute.
+2. Because all jobs are complete at different times, there's a loop to check that all jobs have been completed before downloading the results. If you don't do this, you'll likely see an error when trying to download the results. The `while True` loop is used to monitor the status of jobs and wait for them to complete.
+3. When downloading the results, the IPFS get often times out, so I wrapped that in a loop. The `for i in range(0, 5)` loop in the `getResultsFromJob` function involves retrying the `bacalhau get` operation if it fails to complete successfully.
 
 Let's run it!
 
@@ -177,18 +169,28 @@ Let's run it!
 python bacalhau.py
 ```
 
-Hopefully, the results directory contains all the combined results from the jobs we just executed. Here's we're expecting to see CSV files:
+Hopefully, the `results` directory contains all the combined results from the jobs we just executed. Here's we're expecting to see CSV files:
 
 
 ```bash
 %%bash
-ls -l results
+ls results
+
+Expected Output:
+transactions_00000000_00049999.csv  transactions_00150000_00199999.csv
+transactions_00050000_00099999.csv  transactions_00200000_00249999.csv
+transactions_00100000_00149999.csv  transactions_00250000_00299999.csv
+
 ```
 
 Success! We've now executed a bunch of jobs in parallel using Python. This is a great way to execute lots of jobs in a repeatable manner. You can alter the file above for your purposes.
 
-### Next Steps
+## Next Steps
 
 You might also be interested in the following examples:
 
-* [Analysing Ethereum Data with Python](../../data-engineering/blockchain-etl/index.md)
+[Analysing Data with Python Pandas](../python-pandas/index.md)
+
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
diff --git a/docs/docs/examples/workload-onboarding/r-custom-docker-prophet/index.md b/docs/docs/setting-up/workload-onboarding/r-custom-docker-prophet/index.md
similarity index 53%
rename from docs/docs/examples/workload-onboarding/r-custom-docker-prophet/index.md
rename to docs/docs/setting-up/workload-onboarding/r-custom-docker-prophet/index.md
index ca5cce7aa6..01b8d43705 100644
--- a/docs/docs/examples/workload-onboarding/r-custom-docker-prophet/index.md
+++ b/docs/docs/setting-up/workload-onboarding/r-custom-docker-prophet/index.md
@@ -11,21 +11,24 @@ sidebar_position: 8
 
 This example will walk you through building Time Series Forecasting using [Prophet](https://github.com/facebook/prophet). Prophet is a forecasting procedure implemented in R and Python. It is fast and provides completely automated forecasts that can be tuned by hand by data scientists and analysts.
 
-### TL;DR
-
-Quick script to run custom R container in Bacalhau
+:::info
+Quick script to run custom R container on Bacalhau:
 
 ```bash
-bacalhau docker run -i ipfs://QmY8BAftd48wWRYDf5XnZGkhwqgjpzjyUG3hN1se6SYaFt:/example_wp_log_R.csv ghcr.io/bacalhau-project/examples/r-prophet:0.0.2 -- Rscript Saturating-Forecasts.R "/example_wp_log_R.csv" "/outputs/output0.pdf" "/outputs/output1.pdf"
+bacalhau docker run \
+    -i ipfs://QmY8BAftd48wWRYDf5XnZGkhwqgjpzjyUG3hN1se6SYaFt:/example_wp_log_R.csv \
+    ghcr.io/bacalhau-project/examples/r-prophet:0.0.2 \
+    -- Rscript Saturating-Forecasts.R "/example_wp_log_R.csv" "/outputs/output0.pdf" "/outputs/output1.pdf"
 ```
+:::
 
 ## Prerequisites
 
-To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
 
-## Running Prophet in R Locally
+## 1. Running Prophet in R Locally
 
-Open R studio or R-supported IDE. If you want to run this on a notebook server, then make sure you use an R kernel. Prophet is a CRAN package so you can use install.packages to install the prophet package.
+Open R studio or R-supported IDE. If you want to run this on a notebook server, then make sure you use an R kernel. Prophet is a CRAN package, so you can use install.packages to install the prophet package:
 
 
 ```bash
@@ -34,7 +37,7 @@ R -e "install.packages('prophet',dependencies=TRUE, repos='http://cran.rstudio.c
 ```
 
 
-After installation is finished, you can download the example data that is stored in IPFS.
+After installation is finished, you can download the example data that is stored in IPFS:
 
 
 ```bash
@@ -51,11 +54,16 @@ mkdir -p outputs
 mkdir -p R
 ```
 
+Create a new file called `Saturating-Forecasts.R` and in it paste the following script:
 
 ```python
 %%writefile Saturating-Forecasts.R
+
+# Library Inclusion
 library('prophet')
 
+
+# Command Line Arguments:
 args = commandArgs(trailingOnly=TRUE)
 args
 
@@ -64,6 +72,7 @@ output = args[2]
 output1 = args[3]
 
 
+# File Path Processing:
 I <- paste("", input, sep ="")
 
 O <- paste("", output, sep ="")
@@ -71,8 +80,11 @@ O <- paste("", output, sep ="")
 O1 <- paste("", output1 ,sep ="")
 
 
+# Read CSV Data:
 df <- read.csv(I)
 
+
+# Forecasting 1:
 df$cap <- 8.5
 m <- prophet(df, growth = 'logistic')
 
@@ -83,6 +95,7 @@ pdf(O)
 plot(m, fcst)
 dev.off()
 
+# Forecasting 2:
 df$y <- 10 - df$y
 df$cap <- 6
 df$floor <- 1.5
@@ -94,22 +107,36 @@ pdf(O1)
 plot(m, fcst)
 dev.off()
 ```
+This script performs time series forecasting using the Prophet library in R, taking input data from a CSV file, applying the forecasting model, and generating plots for analysis.
 
 
+Let's have a look at the command below:
 ```bash
 %%bash
 Rscript Saturating-Forecasts.R "example_wp_log_R.csv" "outputs/output0.pdf" "outputs/output1.pdf"
 ```
+This command uses Rscript to execute the script that was created and written to the `Saturating-Forecasts.R` file.  
+
+The input parameters provided in this case are the names of input and output files:
 
-## Running R Prophet on Bacalhau
+`example_wp_log_R.csv` - the example data that was previously downloaded.   
+
+`outputs/output0.pdf` - the name of the file to save the first forecast plot.  
+
+`outputs/output1.pdf` - the name of the file to save the second forecast plot.
+
+
+
+## 2. Running R Prophet on Bacalhau
 
 To use Bacalhau, you need to package your code in an appropriate format. The developers have already pushed a container for you to use, but if you want to build your own, you can follow the steps below. You can view a [dedicated container example](../custom-containers/index.md) in the documentation.
 
-## Containerize Script with Docker
+## 3. Containerize Script with Docker
 
 To build your own docker container, create a `Dockerfile`, which contains instructions to build your image.
 
 ```
+%%writefile Dockerfile
 FROM r-base
 RUN R -e "install.packages('prophet',dependencies=TRUE, repos='http://cran.rstudio.com/')"
 RUN mkdir /R
@@ -118,29 +145,29 @@ COPY Saturating-Forecasts.R R
 WORKDIR /R
 ```
 
-These commands specify how the image will be built, and what extra requirements will be included. We use r-base as the base image and then install the prophet package. We then copy the R script into the container and set the working directory to the R folder.
+These commands specify how the image will be built, and what extra requirements will be included. We use `r-base` as the base image and then install the `prophet` package. We then copy the `Saturating-Forecasts.R` script into the container and set the working directory to the `R` folder.
 
 
 ### Build the container
 
-We will run `docker build` command to build the container;
+We will run `docker build` command to build the container:
 
 ```
 docker build -t <hub-user>/<repo-name>:<tag> .
 ```
 
-Before running the command replace;
+Before running the command replace:
 
-- **hub-user** with your docker hub username, If you don’t have a docker hub account [follow these instructions to create docker account](https://docs.docker.com/docker-id/), and use the username of the account you created
+**`hub-user`** with your docker hub username. If you don’t have a docker hub account [follow these instructions to create docker account](https://docs.docker.com/docker-id/), and use the username of the account you created
 
-- **repo-name** with the name of the container, you can name it anything you want
+**`repo-name`** with the name of the container, you can name it anything you want
 
-- **tag** this is not required but you can use the latest tag
+**`tag`** this is not required but you can use the `latest` tag
 
 In our case:
 
 ```bash
-docker buildx build --platform linux/amd64 --push -t ghcr.io/bacalhau-project/examples/r-prophet:0.0.1 .
+docker buildx build --platform linux/amd64 -t ghcr.io/bacalhau-project/examples/r-prophet:0.0.1 .
 ```
 
 ### Push the container
@@ -154,10 +181,10 @@ docker push <hub-user>/<repo-name>:<tag>
 In our case:
 
 ```bash
-docker push --platform linux/amd64 --push -t ghcr.io/bacalhau-project/examples/r-prophet:0.0.1 .
+docker push ghcr.io/bacalhau-project/examples/r-prophet:0.0.1
 ```
 
-## Running a Job on Bacalhau
+## 4. Running a Job on Bacalhau
 
 The following command passes a prompt to the model and generates the results in the outputs directory. It takes approximately 2 minutes to run.
 
@@ -174,25 +201,27 @@ bacalhau docker run \
 
 ### Structure of the command
 
-Let's look closely at the command above:
+`bacalhau docker run`: call to Bacalhau
 
-* `bacalhau docker run`: call to bacalhau
+`-i ipfs://QmY8BAftd48wWRYDf5XnZGkhwqgjpzjyUG3hN1se6SYaFt:/example_wp_log_R.csv`: Mounting the uploaded dataset at `/inputs` in the execution. It takes two arguments, the first is the IPFS CID (`QmY8BAftd48wWRYDf5XnZGkhwqgjpzjyUG3hN1se6SYaFtz`) and the second is file path within IPFS (`/example_wp_log_R.csv`)
 
-* `-i ipfs://QmY8BAftd48wWRYDf5XnZGkhwqgjpzjyUG3hN1se6SYaFt`: CIDs to use on the job. Mounts them at '/inputs' in the execution.
+`ghcr.io/bacalhau-project/examples/r-prophet:0.0.2`: the name and the tag of the docker image we are using
 
-* `ghcr.io/bacalhau-project/examples/r-prophet:0.0.2`: the name and the tag of the docker image we are using
+`/example_wp_log_R.csv `: path to the input dataset
 
-* `/example_wp_log_R.csv `: path to the input dataset
+`/outputs/output0.pdf`, `/outputs/output1.pdf`: paths to the output
 
-* `/outputs/output0.pdf....`: path to the output
+`Rscript Saturating-Forecasts.R`: execute the R script
 
-* `Rscript Saturating-Forecasts.R`: execute the R script
+When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
 
-When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on.
+```python
+%env JOB_ID={job_id}
+```
 
-## Checking the State of your Jobs
+## 5. Checking the State of your Jobs
 
-- **Job status**: You can check the status of the job using `bacalhau list`.
+**Job status**: You can check the status of the job using `bacalhau list`.
 
 
 ```bash
@@ -202,7 +231,7 @@ bacalhau list --id-filter ${JOB_ID}
 
 When it says `Published` or `Completed`, that means the job is done, and we can get the results.
 
-- **Job information**: You can find out more information about your job by using `bacalhau describe`.
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
 
 
 ```bash
@@ -210,16 +239,16 @@ When it says `Published` or `Completed`, that means the job is done, and we can
 bacalhau describe ${JOB_ID}
 ```
 
-- **Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory and downloaded our job output to be stored in that directory.
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
 
 
 ```bash
 %%bash
 rm -rf results && mkdir -p results
-bacalhau get $JOB_ID --output-dir results
+bacalhau get ${JOB_ID} --output-dir results
 ```
 
-## Viewing your Job Output
+## 6. Viewing your Job Output
 
 To view the file, run the following command:
 
@@ -231,12 +260,15 @@ ls results/outputs
 
 You can't natively display PDFs in notebooks, so here are some static images of the PDFs:
 
-* output0.pdf
+**output0.pdf**
 
 ![](output0.png)
 
 
-* output1.pdf
+**output1.pdf**
 
 ![](output1.png)
 
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/r-custom-docker-prophet/output0.png b/docs/docs/setting-up/workload-onboarding/r-custom-docker-prophet/output0.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/r-custom-docker-prophet/output0.png
rename to docs/docs/setting-up/workload-onboarding/r-custom-docker-prophet/output0.png
diff --git a/docs/docs/examples/workload-onboarding/r-custom-docker-prophet/output1.png b/docs/docs/setting-up/workload-onboarding/r-custom-docker-prophet/output1.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/r-custom-docker-prophet/output1.png
rename to docs/docs/setting-up/workload-onboarding/r-custom-docker-prophet/output1.png
diff --git a/docs/docs/setting-up/workload-onboarding/r-hello-world/index.md b/docs/docs/setting-up/workload-onboarding/r-hello-world/index.md
new file mode 100644
index 0000000000..33d3b54c05
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/r-hello-world/index.md
@@ -0,0 +1,128 @@
+---
+sidebar_label: "R Script"
+sidebar_position: 9
+---
+# Running a Simple R Script on Bacalhau
+
+
+[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
+
+You can use official Docker containers for each language like R or Python. In this example, we will use the official R container and run it on Bacalhau.
+
+In this tutorial example, we will run a "hello world" R script on Bacalhau.
+
+## Prerequisites
+
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+
+## 1. Running an R Script Locally
+
+To install R follow these instructions [A Installing R and RStudio | Hands-On Programming with R](https://rstudio-education.github.io/hopr/starting.html). After R and RStudio are installed, create and run a script called `hello.R`:
+
+
+```python
+%%writefile hello.R
+print("hello world")
+```
+
+Run the script:
+
+
+```bash
+%%bash
+Rscript hello.R
+```
+
+Next, upload the script to your public storage (in our case, IPFS).  We've already uploaded the script to IPFS and the CID is: `QmVHSWhAL7fNkRiHfoEJGeMYjaYZUsKHvix7L54SptR8ie`. You can look at this by browsing to one of the HTTP IPFS proxies like [ipfs.io](https://ipfs.tech/) or [w3s.link](https://github.com/web3-storage/w3link).
+
+## 2. Running a Job on Bacalhau
+
+Now it's time to run the script on Bacalhau:
+
+
+```bash
+%%bash --out job_id
+bacalhau docker run \
+    --wait \
+    --id-only \
+    -i ipfs://QmQRVx3gXVLaRXywgwo8GCTQ63fHqWV88FiwEqCidmUGhk:/hello.R \
+    r-base \
+    -- Rscript hello.R
+```
+
+### Structure of the command
+
+`bacalhau docker run`: call to Bacalhau
+
+`i ipfs://QmQRVx3gXVLaRXywgwo8GCTQ63fHqWV88FiwEqCidmUGhk:/hello.R`: Mounting the uploaded dataset at `/inputs` in the execution. It takes two arguments, the first is the IPFS CID (`QmQRVx3gXVLaRXywgwo8GCTQ63fHqWV88FiwEqCidmUGhk`) and the second is file path within IPFS (`/hello.R`)
+
+`r-base`: docker official image we are using
+
+`Rscript hello.R`: execute the R script
+
+
+When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
+
+
+```python
+%env JOB_ID={job_id}
+```
+
+
+## 3. Checking the State of your Jobs
+
+**Job status**: You can check the status of the job using `bacalhau list`.
+
+
+
+```bash
+%%bash
+bacalhau list --id-filter ${JOB_ID}
+```
+
+When it says `Published` or `Completed`, that means the job is done, and we can get the results.
+
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
+
+
+```bash
+%%bash
+bacalhau describe  ${JOB_ID}
+```
+
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
+
+
+```bash
+%%bash
+rm -rf results && mkdir results
+bacalhau get ${JOB_ID} --output-dir results
+```
+
+## 4. Viewing your Job Output
+
+To view the file, run the following command:
+
+```bash
+%%bash
+cat results/stdout
+```
+
+### Futureproofing your R Scripts
+
+You can generate the job request using `bacalhau describe` with the `--spec` flag. This will allow you to re-run that job in the future:
+
+
+```bash
+%%bash
+bacalhau describe ${JOB_ID} --spec > job.yaml
+```
+
+
+```bash
+%%bash
+cat job.yaml
+```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
\ No newline at end of file
diff --git a/docs/docs/examples/workload-onboarding/rust-wasm/index.md b/docs/docs/setting-up/workload-onboarding/rust-wasm/index.md
similarity index 62%
rename from docs/docs/examples/workload-onboarding/rust-wasm/index.md
rename to docs/docs/setting-up/workload-onboarding/rust-wasm/index.md
index e87616e896..d54169f740 100644
--- a/docs/docs/examples/workload-onboarding/rust-wasm/index.md
+++ b/docs/docs/setting-up/workload-onboarding/rust-wasm/index.md
@@ -7,21 +7,17 @@ sidebar_position: 10
 
 [![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
 
-Bacalhau supports running jobs as a [WebAssembly (WASM)](https://webassembly.org/) program rather than using a Docker container. This example demonstrates how to compile a [Rust](https://www.rust-lang.org/) project into WebAssembly and run the program on Bacalhau.
-
-## TD;LR
-Run WASM job on Bacalhau
+Bacalhau supports running jobs as a [WebAssembly (WASM)](https://webassembly.org/) program. This example demonstrates how to compile a [Rust](https://www.rust-lang.org/) project into WebAssembly and run the program on Bacalhau.
 
 ### Prerequisites
 
-* To get started, you need to install the Bacalhau client, see more information [here](https://docs.bacalhau.org/getting-started/installation)
-* A working Rust installation with the `wasm32-wasi` target. For example, you can use [`rustup`](https://rustup.rs/) to install Rust and configure it to build WASM targets.
+1. To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md).  
 
-For those using the notebook, these are installed in hidden cells below.
+2. A working Rust installation with the `wasm32-wasi` target. For example, you can use [`rustup`](https://rustup.rs/) to install Rust and configure it to build WASM targets. For those using the notebook, these are installed in hidden cells below.
 
-## Develop a Rust Program Locally
+## 1. Develop a Rust Program Locally
 
-We can use `cargo` (which will have been installed by `rustup`) to start a new project and compile it.
+We can use `cargo` (which will have been installed by `rustup`) to start a new project (`my-program`) and compile it:
 
 
 ```bash
@@ -29,9 +25,10 @@ We can use `cargo` (which will have been installed by `rustup`) to start a new p
 cargo init my-program
 ```
 
+
 We can then write a Rust program. Rust programs that run on Bacalhau can read and write files, access a simple clock, and make use of pseudo-random numbers. They cannot memory-map files or run code on multiple threads.
 
-The below program will make use of the Rust `imageproc` create to resize an image through seam carving, based on [an example from their repository](https://github.com/image-rs/imageproc/blob/master/examples/seam_carving.rs).
+The program below will use the Rust `imageproc` crate to resize an image through seam carving, based on [an example from their repository](https://github.com/image-rs/imageproc/blob/master/examples/seam_carving.rs).
 
 
 ```python
@@ -99,7 +96,9 @@ fn main() {
 }
 ```
 
-We also need to install the `imageproc` and `image` libraries and switch off the default features to make sure that multi-threading is disabled.
+In the main function `main()` an image is loaded, the original is saved, and then a loop is performed to reduce the width of the image by removing "seams." The results of the process are saved, including the original image with drawn seams and a gradient image with highlighted seams.
+
+We also need to install the `imageproc` and `image` libraries and switch off the default features to make sure that multi-threading is disabled (`default-features = false`). After disabling the default features, you need to explicitly specify only the features that you need:
 
 
 ```python
@@ -119,20 +118,21 @@ version = "0.23.0"
 default-features = false
 ```
 
-We can now build the Rust program into a WASM blob using `cargo`.
+We can now build the Rust program into a WASM blob using `cargo`:
 
 
 ```bash
 %%bash
 cd my-program && cargo build --target wasm32-wasi --release
 ```
+This command navigates to the `my-program` directory and builds the project using Cargo with the target set to `wasm32-wasi` in release mode.
 
-This will generate a WASM file at `./my-program/target/wasm32-wasi/my-program.wasm` which can now be run on Bacalhau.
+This will generate a WASM file at `./my-program/target/wasm32-wasi/release/my-program.wasm` which can now be run on Bacalhau.
 
-## Running WASM on Bacalhau
+## 2. Running WASM on Bacalhau
 Now that we have a WASM binary, we can upload it to IPFS and use it as input to a Bacalhau job.
 
-The -i switch allows specifying a URI to be mounted as a named volume in the job, which can be an IPFS CID, HTTP URL, or S3 object.
+The `-i` flag allows specifying a URI to be mounted as a named volume in the job, which can be an IPFS CID, HTTP URL, or S3 object.
 
 For this example, we are using an image of the Statue of Liberty that has been pinned to a storage facility.
 
@@ -144,14 +144,35 @@ bacalhau wasm run ./my-program/target/wasm32-wasi/release/my-program.wasm _start
     -i ipfs://bafybeifdpl6dw7atz6uealwjdklolvxrocavceorhb3eoq6y53cbtitbeu:/inputs
 ```
 
-We can now get the results. When we view the files, we can see the original image, the resulting shrunk image, and the seams that were removed.
 
+### Structure of the Commands
+
+`bacalhau wasm run`: call to Bacalhau
+
+`./my-program/target/wasm32-wasi/release/my-program.wasm`: the path to the WASM file that will be executed
+
+` _start`: the entry point of the WASM program, where its execution begins
+
+`--id-only`: this flag indicates that only the identifier of the executed job should be returned
+
+`-i ipfs://bafybeifdpl6dw7atz6uealwjdklolvxrocavceorhb3eoq6y53cbtitbeu:/inputs`: input data volume that will be accessible within the job at the specified destination path
+
+When a job is submitted, Bacalhau prints out the related job_id. We store that in an environment variable so that we can reuse it later on:
 
 ```python
 %env JOB_ID={job_id}
 ```
 
 
+
+
+
+You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`wasm_results`) and downloaded our job output to be stored in that directory.
+
+We can now get the results. 
+
+
+
 ```bash
 %%bash
 rm -rf wasm_results && mkdir -p wasm_results
@@ -160,6 +181,7 @@ bacalhau get ${JOB_ID} --output-dir wasm_results
 
 ## Viewing Job Output
 
+When we view the files, we can see the original image, the resulting shrunk image, and the seams that were removed.
 
 ```python
 import IPython.display as display
@@ -201,4 +223,5 @@ display.Image("./wasm_results/outputs/shrunk.png")
 ![png](index_files/index_20_0.png)
     
 
-
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel). 
diff --git a/docs/docs/examples/workload-onboarding/rust-wasm/index_files/index_18_0.png b/docs/docs/setting-up/workload-onboarding/rust-wasm/index_files/index_18_0.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/rust-wasm/index_files/index_18_0.png
rename to docs/docs/setting-up/workload-onboarding/rust-wasm/index_files/index_18_0.png
diff --git a/docs/docs/examples/workload-onboarding/rust-wasm/index_files/index_19_0.png b/docs/docs/setting-up/workload-onboarding/rust-wasm/index_files/index_19_0.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/rust-wasm/index_files/index_19_0.png
rename to docs/docs/setting-up/workload-onboarding/rust-wasm/index_files/index_19_0.png
diff --git a/docs/docs/examples/workload-onboarding/rust-wasm/index_files/index_20_0.png b/docs/docs/setting-up/workload-onboarding/rust-wasm/index_files/index_20_0.png
similarity index 100%
rename from docs/docs/examples/workload-onboarding/rust-wasm/index_files/index_20_0.png
rename to docs/docs/setting-up/workload-onboarding/rust-wasm/index_files/index_20_0.png
diff --git a/docs/docs/setting-up/workload-onboarding/trivial-python/index.md b/docs/docs/setting-up/workload-onboarding/trivial-python/index.md
new file mode 100644
index 0000000000..97fb6743a5
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/trivial-python/index.md
@@ -0,0 +1,120 @@
+---
+sidebar_label: "Python File"
+sidebar_position: 12
+description: How to run a Python file hosted on Bacalhau
+---
+# Running a Python Script
+
+
+[![stars - badge-generator](https://img.shields.io/github/stars/bacalhau-project/bacalhau?style=social)](https://github.com/bacalhau-project/bacalhau)
+
+This tutorial serves as an introduction to Bacalhau. In this example, you'll be executing a simple  "Hello, World!" Python script hosted on a website on Bacalhau.
+
+### Prerequisites
+
+To get started, you need to install the Bacalhau client, see more information [here](../../../getting-started/installation.md)
+
+## 1. Running Python Locally 
+
+We'll be using a very simple Python script that displays the [traditional first greeting](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program). Create a file called `hello-world.py`:
+
+```python
+%%writefile hello-world.py
+print("Hello, world!")
+```
+
+```python
+%cat hello-world.py
+```
+
+Running the script to print out the output:
+
+```bash
+%%bash
+python3 hello-world.py
+```
+After the script has run successfully locally we can now run it on Bacalhau.
+
+## 2. Running a Bacalhau Job
+
+
+
+To submit a workload to Bacalhau you can use the `bacalhau docker run` command. This command allows passing input data into the container using [content identifier (CID)](https://github.com/multiformats/cid) volumes, we will be using the `--input URL:path` [argument](../../../dev/cli-reference/all-flags.md#docker-run) for simplicity. This results in Bacalhau mounting a *data volume* inside the container. By default, Bacalhau mounts the input volume at the path `/inputs` inside the container.
+
+:::info
+[Bacalhau overwrites the default entrypoint](https://github.com/filecoin-project/bacalhau/blob/v0.2.3/cmd/bacalhau/docker_run.go#L64), so we must run the full command after the `--` argument.
+:::
+
+
+```bash
+%%bash --out job_id
+bacalhau docker run \
+    --id-only \
+    --input https://raw.githubusercontent.com/bacalhau-project/examples/151eebe895151edd83468e3d8b546612bf96cd05/workload-onboarding/trivial-python/hello-world.py \
+    python:3.10-slim \
+    -- python3 /inputs/hello-world.py
+```
+
+### Structure of the command
+
+`bacalhau docker run`: call to Bacalhau
+
+`--id-only`: specifies that only the job identifier (job_id) will be returned after executing the container, not the entire output
+
+`--input https://raw.githubusercontent.com/bacalhau-project/examples/151eebe895151edd83468e3d8b546612bf96cd05/workload-onboarding/trivial-python/hello-world.py \`: indicates where to get the input data for the container. In this case, the input data is downloaded from the specified URL, which represents the Python script "hello-world.py".
+
+`python:3.10-slim`: the Docker image that will be used to run the container. In this case, it uses the Python 3.10 image with a minimal set of components (slim).
+
+`--`: This double dash is used to separate the Bacalhau command options from the command that will be executed inside the Docker container.
+
+`python3 /inputs/hello-world.py`: running the `hello-world.py` Python script stored in `/inputs`.
+
+
+When a job is submitted, Bacalhau prints out the related `job_id`. We store that in an environment variable so that we can reuse it later on:
+
+
+```python
+%env JOB_ID={job_id}
+```
+
+## 3. Checking the State of your Jobs
+
+**Job status**: You can check the status of the job using `bacalhau list`.
+
+
+```bash
+%%bash
+bacalhau list --id-filter ${JOB_ID} --no-style
+```
+
+When it says `Published` or `Completed`, that means the job is done, and we can get the results.
+
+**Job information**: You can find out more information about your job by using `bacalhau describe`.
+
+
+```bash
+%%bash
+bacalhau describe ${JOB_ID}
+```
+
+**Job download**: You can download your job results directly by using `bacalhau get`. Alternatively, you can choose to create a directory to store your results. In the command below, we created a directory (`results`) and downloaded our job output to be stored in that directory.
+
+
+```bash
+%%bash
+rm -rf results && mkdir results
+bacalhau get ${JOB_ID} --output-dir results
+```
+
+## 4. Viewing your Job Output
+
+To view the file, run the following command:
+
+
+```bash
+%%bash
+cat results/stdout
+```
+
+## Support
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel).
diff --git a/docs/docs/setting-up/workload-onboarding/wasm-workload-onboarding.md b/docs/docs/setting-up/workload-onboarding/wasm-workload-onboarding.md
new file mode 100644
index 0000000000..bc82294970
--- /dev/null
+++ b/docs/docs/setting-up/workload-onboarding/wasm-workload-onboarding.md
@@ -0,0 +1,143 @@
+---
+sidebar_label: 'Workloads (WebAssembly)'
+sidebar_position: 3
+---
+# WebAssembly (WASM) Workloads
+
+Bacalhau supports running programs that are compiled to [WebAssembly (WASM)](https://webassembly.org/). With the Bacalhau client, you can upload WASM programs, retrieve data from public storage, read and write data, receive program arguments, and access environment variables.
+
+## Prerequisites and Limitations
+
+1. **Supported WebAssembly System Interface (WASI)**  
+Bacalhau can run compiled WASM programs that expect the WebAssembly System Interface (WASI) Snapshot 1. Through this interface, WebAssembly programs can access data, environment variables, and program arguments.
+
+2. **Networking Restrictions**  
+All ingress/egress networking is disabled – you won't be able to pull `data/code/weights` etc. from an external source. WASM jobs can say what data they need using URLs or CIDs (Content IDentifier) and can then access the data by reading from the filesystem.
+
+3. **Single-Threading**  
+There is no multi-threading as WASI does not expose any interface for it.
+
+
+## Onboarding Your Workload
+
+### Step 1: Replace network operations with filesystem reads and writes
+
+If your program typically involves reading from and writing to network endpoints, follow these steps to adapt it for Bacalhau:
+
+1. **Replace Network Operations:**  
+Instead of making HTTP requests to external servers (e.g., example.com), modify your program to read data from the local filesystem.
+
+2. **Input Data Handling:**
+Specify the input data location in Bacalhau using the `--input` flag when running the job. For instance, if your program used to fetch data from `example.com`, read from the `/inputs` folder locally, and provide the URL as input when executing the Bacalhau job. For example, `--input http://example.com`.  
+
+3. **Output Handling:**
+Adjust your program to output results to standard output (`stdout`) or standard error (`stderr`) pipes. Alternatively, you can write results to the filesystem, typically into an output mount. In the case of WASM jobs, a default folder at `/outputs` is available, ensuring that data written there will persist after the job concludes.
+
+By making these adjustments, you can effectively transition your program to operate within the Bacalhau environment, utilizing filesystem operations instead of traditional network interactions.
+
+:::tip
+You can specify additional or different output mounts using the `-o` flag.
+:::
+
+### Step 2: Configure your compiler to output WASI-compliant WebAssembly
+
+You will need to compile your program to WebAssembly that expects WASI. Check the instructions for your compiler to see how to do this.
+
+For example, Rust users can specify the `wasm32-wasi` target to `rustup` and `cargo` to get programs compiled for WASI WebAssembly. See [the Rust example](../workload-onboarding/rust-wasm/index.md) for more information on this.
+
+### Step 3: Upload the input data
+
+Data is identified by its content identifier (CID) and can be accessed by anyone who knows the CID. You can use either of these methods to upload your data:
+
+ [Copy data from a URL to public storage](../data-ingestion/from-url.md)  
+ [Pin Data to public storage](../data-ingestion/pin.md)  
+ [Copy Data from S3 Bucket to public storage](../data-ingestion/s3.md)
+
+:::info
+You can mount your data anywhere on your machine, and Bacalhau will be able to run against that data
+:::
+
+### Step 4: Run your program
+
+You can run a WebAssembly program on Bacalhau using the `bacalhau wasm run` command. 
+
+```shell
+$ bacalhau wasm run
+```
+
+**Run Locally Compiled Program:**
+
+If your program is locally compiled, specify it as an argument. For instance, running the following command will upload and execute the `main.wasm` program:
+
+```shell
+$ bacalhau wasm run main.wasm
+```
+
+
+:::caution
+The program you specify will be uploaded to a Bacalhau storage node and will be publicly available.
+:::
+
+
+**Alternative Program Specification:**
+
+ You can use a Content IDentifier (CID) for a specific WebAssembly program.
+
+
+```shell
+$ bacalhau wasm run Qmajb9T3jBdMSp7xh2JruNrqg3hniCnM6EUVsBocARPJRQ
+```
+
+**Input Data Specification:**
+
+Make sure to specify any input data using `--input` flag.
+
+```shell
+$ bacalhau wasm run --input http://example.com
+```
+This ensures the necessary data is available for the program's execution.
+
+
+#### Program arguments
+
+You can give the WASM program arguments by specifying them after the program path or CID. If the WASM program is already compiled and located in the current directory, you can run it by adding arguments after the file name:
+
+```shell
+$ bacalhau wasm run echo.wasm hello world
+```
+
+For a specific WebAssembly program, run:
+
+```shell
+$ bacalhau wasm run Qmajb9T3jBdMSp7xh2JruNrqg3hniCnM6EUVsBocARPJRQ hello world
+```
+
+
+:::tip
+
+Write your program to use program arguments to specify input and output paths. This makes your program more flexible in handling different configurations of input and output volumes.
+
+For example, instead of hard-coding your program to read from `/inputs/data.txt`, accept a program argument that should contain the path and then specify the path as an argument to `bacalhau wasm run`:
+
+```shell
+$ bacalhau wasm run prog.wasm /inputs/data.txt
+```
+
+Your language of choice should contain a standard way of reading program arguments that will work with WASI.
+:::
+
+#### Environment variables
+
+You can also specify environment variables using the `-e` flag.
+
+```shell
+$ bacalhau wasm run prog.wasm -e HELLO=world
+```
+
+## Examples
+
+See [the Rust example](../workload-onboarding/rust-wasm/index.md) for a workload that leverages WebAssembly support.
+## Support
+
+
+If you have questions or need support or guidance, please reach out to the [Bacalhau team via Slack](https://bacalhauproject.slack.com/ssb/redirect) (**#general** channel)
diff --git a/docs/docs/topic-guides/_category_.yml b/docs/docs/topic-guides/_category_.yml
deleted file mode 100644
index 1700b68948..0000000000
--- a/docs/docs/topic-guides/_category_.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-label: "Topic Guides"
-link:
-  type: 'generated-index'
diff --git a/docs/docusaurus.config.js b/docs/docusaurus.config.js
index 6855c19122..299ebec8d2 100644
--- a/docs/docusaurus.config.js
+++ b/docs/docusaurus.config.js
@@ -111,7 +111,7 @@ const config = {
               },
               {
                 label: "FAQs",
-                to: "/troubleshooting/faqs",
+                to: "/faqs",
               },
             ],
           },
diff --git a/docs/redirects.js b/docs/redirects.js
index b608793e47..bc5e883bb3 100644
--- a/docs/redirects.js
+++ b/docs/redirects.js
@@ -1,4 +1,4 @@
 module.exports = [
-    { to: '/references/sdk/python-sdk', from: '/sdk/python-sdk' },
-    { to: '/category/sdk', from: '/sdk' },
+    { to: '/integration/python-sdk', from: '/sdk/python-sdk' },
+    { to: '/integration/python-sdk', from: '/sdk' },
 ];
diff --git a/docs/sidebars.js b/docs/sidebars.js
index 3dc7e2f4dc..d016aa2b3c 100644
--- a/docs/sidebars.js
+++ b/docs/sidebars.js
@@ -16,22 +16,54 @@ module.exports = {
     'intro',
     {
       type: 'category',
-      label: 'Getting Started',
+      label: 'Quick Start',
       link: {
         type: 'generated-index',
         slug: '/getting-started',
-        title: 'Getting Started',
+        title: 'Quick Start',
         description: "Get Started with Bacalhau!",
       },
       collapsed: false,
       items: [
-        'getting-started/architecture',
         'getting-started/installation',
+        'getting-started/architecture',
         'getting-started/docker-workload-onboarding',
         'getting-started/wasm-workload-onboarding',
         'getting-started/resources'
       ],
     },
+    {
+      type: 'category',
+      label: 'Setting Up',
+      link: {
+        type: 'generated-index',
+        title: 'Setting Up',
+        slug: '/setting-up',
+      },
+      collapsed: true,
+      items: [
+        {
+          type: 'autogenerated',
+          dirName: 'setting-up',
+        },
+      ],
+    },
+    {
+      type: 'category',
+      label: 'Advanced Guides',
+      link: {
+        type: 'generated-index',
+        title: 'Advanced Guides',
+        slug: '/advanced-guides',
+      },
+      collapsed: true,
+      items: [
+        {
+          type: 'autogenerated',
+          dirName: 'dev',
+        },
+      ]
+    },
     {
       type: 'category',
       label: 'Examples',
@@ -54,31 +86,6 @@ module.exports = {
             'examples/case-studies/duckdb-log-processing/index',
           ],
         },
-        {
-          type: 'category',
-          label: 'Workload Onboarding',
-          link: {
-            type: 'generated-index',
-            description: "This directory contains examples relating to performing common tasks with Bacalhau.",
-          },
-          items: [
-            'examples/workload-onboarding/bacalhau-docker-image/index',
-            'examples/workload-onboarding/Reading-From-Multiple-S3-Buckets/index',
-            'examples/workload-onboarding/Running-Jupyter-Notebook/index',
-            'examples/workload-onboarding/Prolog-Hello-World/index',
-            'examples/workload-onboarding/Python-Custom-Container/index',
-            'examples/workload-onboarding/python-pandas/index',
-            'examples/workload-onboarding/r-custom-docker-prophet/index',
-            'examples/workload-onboarding/r-hello-world/index',
-            'examples/workload-onboarding/CUDA/index',
-            'examples/workload-onboarding/rust-wasm/index',
-            'examples/workload-onboarding/Sparkov-Data-Generation/index',
-            'examples/workload-onboarding/custom-containers/index',
-            'examples/workload-onboarding/CUDA/index',
-            'examples/workload-onboarding/trivial-python/index',
-            'examples/workload-onboarding/python-script/index',
-          ],
-        },
         {
           type: 'category',
           label: 'Data Engineering',
@@ -146,125 +153,22 @@ module.exports = {
     },
     {
       type: 'category',
-      label: 'Topic Guides',
-      link: {
-        type: 'generated-index',
-        title: 'Topic Guides',
-        slug: '/topic-guides',
-      },
-      collapsed: true,
-      items: [
-        {
-          type: 'autogenerated',
-          dirName: 'topic-guides',
-        },
-      ],
-    },
-    {
-      type: 'category',
-      label: 'Data Ingestion',
-      link: {
-        type: 'generated-index',
-        slug: '/data-ingestion',
-        title: 'Data Ingestion',
-      },
-      collapsed: true,
-      items: [
-        'data-ingestion/from-url',
-        'data-ingestion/pin',
-        'data-ingestion/s3',
-      ],
-    },
-    {
-      type: 'category',
-      label: 'Process',
-      link: {
-        type: 'generated-index',
-        slug: '/process',
-        title: 'Process',
-      },
-      collapsed: true,
-      items: [
-        'next-steps/gpu',
-        'next-steps/networking',
-        'next-steps/private-cluster',
-        'next-steps/update-checks',
-      ],
-    },
-    {
-      type: 'category',
-      label: 'Running a Node',
-      link: {
-        type: 'generated-index',
-        title: 'Running a node',
-        slug: '/running-node',
-      },
-      collapsed: true,
-      items: [
-        'running-node/quick-start',
-        'running-node/quick-start-docker',
-        'running-node/networking',
-        'running-node/storage-providers',
-        'running-node/job-selection',
-        'running-node/resource-limits',
-        'running-node/timeouts',
-        'running-node/test-network',
-        'running-node/gpu',
-        'running-node/persistence',
-        'running-node/configuring-tls',
-        'running-node/windows-support',
-        'running-node/observability',
-        'running-node/configuration',
-        'running-node/webui'
-      ],
-    },
-    {
-      type: 'category',
-      label: 'References',
-      link: {
-        type: 'generated-index',
-        title: 'References',
-        slug: '/references',
-      },
-      collapsed: true,
-      items: [
-        {
-          type: 'autogenerated',
-          dirName: 'references',
-        },
-      ],
-    },
-    {
-      type: 'category',
-      label: 'FAQS',
-      link: {
-        type: 'generated-index',
-        title: 'Troubleshooting',
-        slug: '/troubleshooting',
-      },
-      collapsed: true,
-      items: [
-        'troubleshooting/debugging',
-        'troubleshooting/faqs',
-        'all-flags',
-      ],
-    },
-    {
-      type: 'category',
-      label: 'Integration',
+      label: 'Integrations',
       link: {
         type: 'generated-index',
-        title: 'Integration',
+        title: 'Integrations',
         slug: '/integration',
       },
       collapsed: true,
       items: [
+        'integration/python-sdk',
         'integration/apache-airflow',
         'integration/amplify',
         'integration/lilypad',
         'integration/wasm-observe'
       ],
     },
+    'faqs',
     {
       type: 'category',
       label: 'Community',
@@ -279,22 +183,6 @@ module.exports = {
         'community/style-guide',
         'community/ways-to-contribute',
       ],
-    },
-    {
-      type: 'category',
-      label: 'Developing',
-      link: {
-        type: 'generated-index',
-        title: 'Developing Bacalhau',
-        slug: '/dev',
-      },
-      collapsed: true,
-      items: [
-        {
-          type: 'autogenerated',
-          dirName: 'dev',
-        },
-      ]
-    },
+    }
   ]
 }
diff --git a/docs/static/img/architecture/System-Components.png b/docs/static/img/architecture/System-Components.png
new file mode 100644
index 0000000000..a1c1e0fd36
Binary files /dev/null and b/docs/static/img/architecture/System-Components.png differ
diff --git a/docs/static/img/architecture/architecture-overview.webp b/docs/static/img/architecture/architecture-overview.webp
new file mode 100644
index 0000000000..2d050dbdfa
Binary files /dev/null and b/docs/static/img/architecture/architecture-overview.webp differ
diff --git a/docs/static/img/installation/bacalhau-get-jobid.png b/docs/static/img/installation/bacalhau-get-jobid.png
new file mode 100644
index 0000000000..68edca77d9
Binary files /dev/null and b/docs/static/img/installation/bacalhau-get-jobid.png differ
diff --git a/docs/static/img/installation/bacalhau-get-myfolder1.png b/docs/static/img/installation/bacalhau-get-myfolder1.png
new file mode 100644
index 0000000000..3b7088004d
Binary files /dev/null and b/docs/static/img/installation/bacalhau-get-myfolder1.png differ
diff --git a/docs/static/img/installation/bacalhau-list1.png b/docs/static/img/installation/bacalhau-list1.png
new file mode 100644
index 0000000000..32a5464b74
Binary files /dev/null and b/docs/static/img/installation/bacalhau-list1.png differ
diff --git a/docs/static/img/installation/tree-jobid1.png b/docs/static/img/installation/tree-jobid1.png
new file mode 100644
index 0000000000..1b6069ea62
Binary files /dev/null and b/docs/static/img/installation/tree-jobid1.png differ


Test patch:
diff --git a/docs/docs/running-node/test-network.md b/docs/docs/setting-up/running-node/test-network.md
similarity index 100%
rename from docs/docs/running-node/test-network.md
rename to docs/docs/setting-up/running-node/test-network.md