diff --git a/docs/develop/dynamic-content.md b/docs/develop/dynamic-content.md
new file mode 100644
index 00000000..c9a1770d
--- /dev/null
+++ b/docs/develop/dynamic-content.md
@@ -0,0 +1,153 @@
+---
+title: Dynamic Content
+id: dynamic-content
+sidebar_label: Dynamic Content
+---
+
+:::warning
+Under construction, set for major revisions to incorporate content from manifests, rout, and host your website pages
+:::
+
+
+## Feeds for Dynamic Content
+
+:::info
+Although all data on Swarm is immutable, feeds provide an updatable reference that lets you simulate dynamic content. A feed is an append‑only sequence of updates that always resolves to its latest entry through a stable feed manifest.
+:::
+
+:::tip
+If you are not familiar with feeds, read:
+- Bee docs: /docs/develop/tools-and-features/feeds/
+- Bee-JS docs: https://bee-js.ethswarm.org/docs/soc-and-feeds/
+:::
+
+Single‑page applications (SPAs) deployed on Swarm work best when their static assets can be updated independently. Instead of reuploading the entire site when one file changes, you can create a separate feed manifest for each asset. Each asset feed provides a stable URL that always resolves to the latest version of that file.
+
+## Why Use Per‑Asset Feeds
+
+- Each React/Vite build artifact (HTML, JS, CSS, images) becomes individually updatable.
+- Every asset has a dedicated feed manifest with its own stable Swarm URL.
+- Updating a single file only updates its feed; the rest of the site stays untouched.
+- This keeps deployments small, fast, and cost‑efficient.
+
+## Architecture Overview
+
+| Asset                | Feed Topic      | Purpose                     |
+|----------------------|-----------------|-----------------------------|
+| Main site bundle     | `website`       | HTML/JS/CSS entry point     |
+| CSS theme            | `main-css`      | Global styling              |
+| JS bundle            | `main-js`       | Application logic           |
+| Images               | `img-*`         | Media resources             |
+
+Each asset has:
+- a private key  
+- a feed topic  
+- a feed manifest  
+- a stable Swarm URL (`bzz://<MANIFEST_HASH>/`)
+
+## Generate a Publisher Key
+
+```js
+import crypto from "crypto";
+import { PrivateKey } from "@ethersphere/bee-js";
+
+const hex = "0x" + crypto.randomBytes(32).toString("hex");
+const pk = new PrivateKey(hex);
+
+console.log("Private key:", pk.toHex());
+console.log("Address:", pk.publicKey().address().toHex());
+```
+
+## Create a Feed for an Asset
+
+```js
+import { Bee, PrivateKey, Topic } from "@ethersphere/bee-js";
+
+const bee = new Bee("http://localhost:1633");
+const batchId = "<BATCH_ID>";
+
+const pk = new PrivateKey("<ASSET_PRIVATE_KEY>");
+const topic = Topic.fromString("main-js");
+const owner = pk.publicKey().address();
+
+const writer = bee.makeFeedWriter(topic, pk);
+```
+
+## Upload an Asset and Publish a Feed Update
+
+```js
+const upload = await bee.uploadFile(batchId, "./dist/assets/index-398a.js");
+await writer.upload(batchId, upload.reference);
+
+const manifest = await bee.createFeedManifest(batchId, topic, owner);
+console.log("JS Manifest:", manifest.toHex());
+```
+
+Stable URL:
+
+```
+bzz://<JS_MANIFEST_HASH>/
+```
+
+This URL never changes, even when you replace the underlying file.
+
+## Updating an Existing Asset
+
+```js
+const nextUpload = await bee.uploadFile(batchId, "./dist/assets/index-new.js");
+await writer.upload(batchId, nextUpload.reference);
+```
+
+No new manifest is created. The old URL now resolves to the updated file.
+
+## Referencing Asset Feeds in Your SPA
+
+Rather than referencing a static build hash, point your SPA to feed manifests.
+
+Example `index.html`:
+
+```html
+<script type="module" src="bzz://<JS_MANIFEST_HASH>/"></script>
+<link rel="stylesheet" href="bzz://<CSS_MANIFEST_HASH>/" />
+```
+
+Example React image reference:
+
+```jsx
+<img src={`bzz://${IMG_MANIFEST_HASH}/`} alt="Hero" />
+```
+
+This makes your deployment resilient to Vite’s changing file names, because Swarm fetches the latest version through the feed instead of the literal file path.
+
+## Example Deployment Workflow
+
+1. Build Vite:
+   ```
+   npm run build
+   ```
+
+2. For each file in `dist/`:
+   - assign (or reuse) a feed topic
+   - upload the file
+   - update its feed
+   - store the feed manifest hash in a hard‑coded list inside your SPA
+
+3. Rebuild your SPA to reference:
+   - `bzz://<JS_FEED_MANIFEST>/`
+   - `bzz://<CSS_FEED_MANIFEST>/`
+   - `bzz://<IMAGE_FEED_MANIFEST>/`
+
+4. Upload only the *main* SPA entrypoint (often a small static HTML + JS shell) using `swarm-cli feed upload`.
+
+This gives you a fully working dynamic SPA with lightweight incremental updates.
+
+## Summary
+
+- Each build artifact gets its own updatable feed.
+- Your SPA uses stable feed manifest URLs instead of build‑hashed filenames.
+- Only changed files need to be uploaded.
+- This keeps deployments fast while ensuring long‑lived URLs remain valid.
+
+The next section (not included here) expands this into a registry‑based system for large dynamic sites.
+
+
diff --git a/docs/develop/host-your-website.md b/docs/develop/host-your-website.md
index a530b4b8..880d5c05 100644
--- a/docs/develop/host-your-website.md
+++ b/docs/develop/host-your-website.md
@@ -478,4 +478,5 @@ This works across:
 * localhost (with a compatible RPC)
 * any ENS-compatible Swarm resolver
 
-You do not need to encode the hash or use any additional tools. `bzz://<hash>` is sufficient.
\ No newline at end of file
+You do not need to encode the hash or use any additional tools. `bzz://<hash>` is sufficient.
+
diff --git a/docs/develop/introduction.md b/docs/develop/introduction.md
index ad9dce1f..e4f6778b 100644
--- a/docs/develop/introduction.md
+++ b/docs/develop/introduction.md
@@ -61,16 +61,17 @@ pagination_next: null
           <span class="hub-card__cta">Open guide</span>
         </a>
       </li>
-      <!--
       <li class="hub-card">
-        <a class="hub-card__link" href="/docs/develop/updatable-content">
-          <h3 class="hub-card__title">Publish Updatable Content</h3>
+        <a class="hub-card__link" href="/docs/develop/dynamic-content">
+          <h3 class="hub-card__title">Dynamic Content</h3>
           <p class="hub-card__desc">
-            Learn how to host dynamic content on Swarm which can change over time such as a blog or personal website.
+            Build dynamic sites on Swarm by updating individual assets through feeds —
+            enabling granular updates, decentralized CDN patterns, and zero-downtime content changes.
           </p>
           <span class="hub-card__cta">Open guide</span>
         </a>
       </li>
+    <!--
       <li class="hub-card">
         <a class="hub-card__link" href="/docs/develop/act">
           <h3 class="hub-card__title">Add Access Control</h3>
diff --git a/docs/develop/manifests.md b/docs/develop/manifests.md
new file mode 100644
index 00000000..6bb847f8
--- /dev/null
+++ b/docs/develop/manifests.md
@@ -0,0 +1,745 @@
+---
+title: Manifests ("Virtual Filesystem")
+id: manifests
+sidebar_label: Manifests ("Virtual Filesystem")
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+Bee nodes — along with tools used for working with them like `bee-js` and `swarm-cli` — let you upload whole folders of files to Swarm.
+
+Swarm doesn’t technically have a filesystem, but can *act like one* using **manifests**, which map readable paths (like `/images/cat.jpg`) to immutable Swarm references.
+
+:::info
+The `bee-js` [`MantarayNode` class](https://github.com/ethersphere/bee-js?tab=readme-ov-file#swarm-primitives) is the main way to work with manifests in NodeJS.
+
+The name comes from an older (now deprecated) library, so you may still see manifests referred to as **“Mantaray manifests.”**
+:::
+
+A manifest is stored as a compact, binary-encoded **prefix trie**. Each node in the trie represents part of a file path and may contain:
+
+- a path segment
+- a trie fork
+- a reference to the root chunk of the file’s Swarm hash
+- file metadata (content type, filename, etc.)
+
+:::info
+A **trie** is a special type of tree that stores data based on **shared prefixes**.  
+This makes lookups fast and avoids repeating long path segments.
+:::
+
+Manifests give Swarm two powerful features:
+
+- A **filesystem-like structure** that preserves the directory layout of uploaded folders.
+- **Clean, customizable website routing**, such as mapping `/about`, `/about/`, and `/about.html` to the same file or redirecting old paths to new ones.
+
+:::info
+Manifests are stored on Swarm as raw binary data.  
+To work with them, these bytes must be **unmarshalled** (decoded) into a structured form.
+
+Although `bee-js` provides this functionality through the `MantarayNode` class, although in theory could be done with any language as long as it preserves the trie data.
+
+After unmarshalling, the data is still quite low-level (for example, many fields are `Uint8Array` values) and usually needs additional processing to make it human-readable. You can find a [script for this in the `ethersphere/examples` repo](https://github.com/ethersphere/examples/blob/main/manifests/printManifestJson.js).
+:::
+
+## Introduction to Manifests
+
+Whenever you upload a folder using Bee’s `/bzz` endpoint (and tools built on top of it such as `bee-js` and `swarm-cli`), Bee automatically creates a manifest that records:
+
+- every file inside the folder
+- the file’s relative path
+- metadata (content type, filename, etc.)
+- optional website metadata (index document, error document)
+
+Uploads made through the Bee API using `/bytes` or `/chunks` **do not** create manifests.  
+However, most developers rarely use these endpoints directly unless they’re building for some custom use-case.
+
+Because `bee-js` and `swarm-cli` call `/bzz` when appropriate, **you get a manifest automatically** whenever you upload a directory.
+
+:::important
+Although working with a manifest may _feel_ like moving or deleting files in a regular filesystem, **no data on Swarm is ever changed**, because all content is immutable.
+
+When you "modify" a manifest, you’re actually creating a _new_ manifest based on the previous one.  
+Removing an entry only removes it from the manifest — the underlying file remains available as long as its postage batch is valid.
+:::
+
+:::tip
+You can find complete examples of all manifest scripts in the ethersphere/examples repo under  
+[`/manifests`](https://github.com/ethersphere/examples/tree/main/manifests).
+
+The `bee-js` [`cheatsheet.ts`](https://github.com/ethersphere/bee-js/blob/master/cheatsheet.ts) and  
+[manifest source code](https://github.com/ethersphere/bee-js/blob/master/src/manifest/manifest.ts)  
+are also excellent references.
+:::
+
+## Manifest Structure Explained
+
+The printed output below shows a **decoded Mantaray manifest** (printed using the `printManifestJson` method from the [`manifestToJson.js` script in the examples repo](https://github.com/ethersphere/examples/blob/main/manifests/manifestToJson.js)), represented as a tree of nodes and forks. Each part plays a specific role in describing how file paths map to Swarm content. Here’s what each piece means.
+
+```json
+{
+    "path": "/",
+    "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "metadata": null,
+    "forks": {
+        "folder/": {
+            "path": "folder/",
+            "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "metadata": null,
+            "forks": {
+                "nested.txt": {
+                    "path": "nested.txt",
+                    "target": "0x9442e445c0d58adea58e0a8afcdcc28ed7642d7a4ff9a253e8f1595faafbb808",
+                    "metadata": {
+                        "Content-Type": "text/plain; charset=utf-8",
+                        "Filename": "nested.txt"
+                    },
+                    "forks": {}
+                },
+                "subfolder/deep.txt": {
+                    "path": "subfolder/deep.txt",
+                    "target": "0x6aa935879ad2a547e57ea6350338bd04ad758977b542e86b31c159f31834b8fc",
+                    "metadata": {
+                        "Content-Type": "text/plain; charset=utf-8",
+                        "Filename": "deep.txt"
+                    },
+                    "forks": {}
+                }
+            }
+        },
+        "root.txt": {
+            "path": "root.txt",
+            "target": "0x98e63f7e826a01634881874246fc873cdf06bb5409ff5f9ec61d1e2de1dd3bf6",
+            "metadata": {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Filename": "root.txt"
+            },
+            "forks": {}
+        }
+    }
+}
+
+```
+
+#### **Node:**
+
+A **Node** represents a position within the manifest trie.
+Each node corresponds to a **path prefix**—a segment of the full file path.
+
+For example:
+
+- A node with `path: folder/` represents the prefix `"folder/"`.
+- A node with `path: nested.txt` represents a leaf for the file `"nested.txt"`.
+
+Every node may contain:
+
+- a path segment (`path`)
+- zero or more child connections (`forks`)
+- optional metadata (e.g., content-type, filename)
+- a `target` (if the node corresponds to an actual file)
+
+#### **Forks:**
+
+A **fork** is an edge from one node to another.
+It is how the trie branches when file paths diverge.
+
+For example, under `folder/`, you see:
+
+```bash
+forks:
+  nested.txt/
+  subfolder/deep.txt/
+```
+
+This means:
+
+- the `folder/` node has two children
+- those children represent different path continuations (i.e., different files)
+
+Forks are how shared prefixes are stored only once. Everything that starts with `"folder/"` branches from the same node.
+
+#### **Path:**
+
+`path` is the **path segment stored at that node**.
+
+Examples:
+
+- `path: root.txt`
+- `path: nested.txt`
+- `path: subfolder/deep.txt`
+
+These are _not_ full paths.
+They represent only the part needed at that position in the trie.
+The full path is reconstructed by walking from the root down through forks.
+
+#### **Target:**
+
+The `target` field holds the **Swarm hash of the file the node points to**.
+
+Example:
+
+```
+target: 0x9442e445c0d58a...
+```
+
+This hash is the immutable reference of the actual content uploaded to Swarm.
+
+**Why is the target sometimes `0x000000...000`?**
+
+Because **not every node corresponds to a file**.
+
+Nodes represent **prefixes**, not necessarily files.
+
+For example:
+
+- The root node (`Node:` at the top) has no file associated so its `target` is zero.
+- The node for `folder/` also has no file associated → target is zero.
+  It is just an internal directory-like prefix.
+
+Only **leaf nodes**, where a file actually exists, have a non-zero target (the file’s Swarm reference).
+
+So:
+
+| Node type               | Example       | Has file? | Target        |
+| ----------------------- | ------------- | --------- | ------------- |
+| Internal directory node | `folder/`     | No        | `0x000...000` |
+| Leaf node               | `nested.txt`  | Yes       | real hash     |
+| Root node               | (top of tree) | No        | `0x000...000` |
+
+:::warning
+The `target` field in a manifest points to the raw file root chunk, not a manifest. `bee-js` and `swarm-cli` file download functions expect a file manifest, even for single-file uploads, so downloading using the raw target hash will not work properly.
+Instead, download files by using the top-level directory manifest and the file’s path within it.
+
+Example:
+
+```bash
+curl http://127.0.0.1:1633/bzz/4d5e6e3eb532131e128b1cd0400ca249f1a6ce5d4005c0b57bf848131300df9d/folder/subfolder/deep.txt
+```
+
+Terminal output:
+
+```bash
+DEEP
+```
+:::
+
+**Metadata:**
+
+Metadata stores information about a file, such as:
+
+- Content-Type
+- Filename
+- Website index/error docs (if configured)
+
+Example:
+
+```yaml
+metadata:
+  Content-Type: text/plain; charset=utf-8
+  Filename: nested.txt
+```
+
+Only **file nodes** (leaf nodes) normally have metadata.
+Internal nodes generally do not.
+
+Metadata helps:
+
+- gateways set HTTP headers (e.g., correct MIME type)
+- browsers display files correctly
+- filesystem-like behavior
+
+#### **Putting it together:**
+
+Let’s interpret a branch:
+
+```
+folder/
+  nested.txt
+```
+
+This means:
+
+1. There is a prefix node representing `"folder/"`.
+2. Inside it, there is a file `"nested.txt"`.
+3. The file node has:
+
+   - a target (its Swarm content hash)
+   - metadata (filename + content-type)
+
+Meanwhile, `"folder/"` has **no file itself**, so its target is zero.
+
+## Manipulating Directories 
+
+In this section we explain how to inspect and modify manifests for non-website directories. You can find the completed [example scripts on GitHub](https://github.com/ethersphere/examples/tree/main/manifests).
+
+In the following guides we will explain how to:
+
+1. Upload a directory and print its manifest
+2. Add a new file 
+3. Move a file (delete + add new entry)
+
+#### Pre-requisites:
+
+- NodeJS and npm
+- Linux or WSL preferred but most commands should work from windows Powershell with slight modifications
+- git
+- The RPC endpoint for a currently running Bee node (either on your machine or remote, try [Swarm Desktop](https://www.ethswarm.org/build/desktop) for a no-hassle way to get started)
+
+If you'd like to follow along with the guides shown below, clone the [`ethersphere/examples` repo](https://github.com/ethersphere/examples/) and navigate to the `/manifests` folder:
+
+```bash
+git clone git@github.com:ethersphere/examples.git
+cd examples/manifests/
+```
+
+Print the file tree to confirm you're in the right place:
+
+```bash
+user@machine:~/examples/manifests$ tree
+.
+├── directory
+│   ├── folder
+│   │   ├── nested.txt
+│   │   └── subfolder
+│   │       └── deep.txt
+│   └── root.txt
+├── env
+├── manifestToJson.js
+├── package-lock.json
+├── package.json
+├── script-01.js
+├── script-02.js
+└── script-03.js
+```
+
+If you're using Powershell you can use the `tree /f` command instead and the output file tree should look similar.
+
+After confirming, run `npm install` to install dependencies:
+
+```bash
+npm install
+```
+
+Locate the `env` file and add a period/full stop to change the file name to a standard `dotenv` file (`.env`). Then modify the file to replace `<BEE_API_ENDPOINT>` with your RPC endpoint and `<BATCH_ID>` with your own postage batch ID:
+
+```bash
+BEE_RPC_URL=<BEE_API_ENDPOINT> // Default: http://localhost:1633
+POSTAGE_BATCH_ID=<BATCH_ID>
+```
+
+Great! Now you're all set up and ready to go.
+
+### Uploading a Directory and Printing Its Manifest
+
+In our first script, we will simply upload our sample directory and print its contents:
+
+**script-01.js (initial upload script)**
+
+```js
+import { Bee, MantarayNode } from "@ethersphere/bee-js";
+import path from "path";
+import { fileURLToPath } from "url";
+import "dotenv/config";
+import { printManifest } from "./printManifest.js";
+
+// Recreate __dirname for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const bee = new Bee(process.env.BEE_RPC_URL);
+const postageBatchId = process.env.POSTAGE_BATCH_ID;
+
+// Build the folder path safely
+const directoryPath = path.join(__dirname, "directory");
+
+async function uploadDirectory() {
+  try {
+    console.log("Uploading directory:", directoryPath);
+
+    // Upload using the resolved directory and get manifest reference
+    const { reference } = await bee.uploadFilesFromDirectory(
+      postageBatchId,
+      directoryPath
+    );
+
+    console.log("Directory uploaded successfully!");
+    console.log("Manifest reference:", reference.toHex());
+
+    // Download each file using its relative path as recorded by the manifest
+    const root = await bee.downloadFile(reference, "root.txt");
+    const nested = await bee.downloadFile(reference, "folder/nested.txt");
+    const deep = await bee.downloadFile(reference, "folder/subfolder/deep.txt");
+
+    // Print out file contents
+    console.log("root.txt:", root.data.toUtf8());
+    console.log("folder/nested.txt:", nested.data.toUtf8());
+    console.log("folder/subfolder/deep.txt:", deep.data.toUtf8());
+
+    // Load the generated manifest
+    const node = await MantarayNode.unmarshal(bee, reference);
+    await node.loadRecursively(bee);
+
+    // Print manifest in human readable format
+    console.log("\n--- Manifest Tree ---");
+    printManifest(node);
+  } catch (error) {
+    console.error("Error during upload or download:", error.message);
+  }
+}
+
+uploadDirectory();
+```
+
+Note that in the script when downloading our files individually we must use the same relative paths that match the directory we uploaded:
+
+```js
+// Download each file using its relative path as recorded by the manifest
+const root = await bee.downloadFile(reference, "root.txt");
+const nested = await bee.downloadFile(reference, "folder/nested.txt");
+const deep = await bee.downloadFile(reference, "folder/subfolder/deep.txt");
+```
+
+Run the script:
+
+```bash
+node script-01.js
+```
+
+If you've set up everything properly, you should see the file contents printed to the terminal followed by the manifest tree:
+
+```json
+Uploading directory: /home/user/examples/manifests/directory
+Directory uploaded successfully!
+Manifest reference: 4d5e6e3eb532131e128b1cd0400ca249f1a6ce5d4005c0b57bf848131300df9d
+root.txt: ROOT
+folder/nested.txt: NESTED
+folder/subfolder/deep.txt: DEEP
+
+--- Manifest Tree ---
+{
+  "path": "/",
+  "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "metadata": null,
+  "forks": {
+    "folder/": {
+      "path": "folder/",
+      "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+      "metadata": null,
+      "forks": {
+        "nested.txt": {
+          "path": "nested.txt",
+          "target": "0x9442e445c0d58adea58e0a8afcdcc28ed7642d7a4ff9a253e8f1595faafbb808",
+          "metadata": {
+            "Content-Type": "text/plain; charset=utf-8",
+            "Filename": "nested.txt"
+          },
+          "forks": {}
+        },
+        "subfolder/deep.txt": {
+          "path": "subfolder/deep.txt",
+          "target": "0x6aa935879ad2a547e57ea6350338bd04ad758977b542e86b31c159f31834b8fc",
+          "metadata": {
+            "Content-Type": "text/plain; charset=utf-8",
+            "Filename": "deep.txt"
+          },
+          "forks": {}
+        }
+      }
+    },
+    "root.txt": {
+      "path": "root.txt",
+      "target": "0x98e63f7e826a01634881874246fc873cdf06bb5409ff5f9ec61d1e2de1dd3bf6",
+      "metadata": {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Filename": "root.txt"
+      },
+      "forks": {}
+    }
+  }
+}
+```
+
+Note and record the manifest reference returned before the manifest tree is printed:
+
+```bash
+Manifest reference: 4d5e6e3eb532131e128b1cd0400ca249f1a6ce5d4005c0b57bf848131300df9d
+```
+
+We will use this in the next section when adding a file manually to the manifest.
+
+### Adding a New File to the Manifest
+
+This script uploads a **new file** (e.g. `newfile.txt`) and then updates the existing manifest so the new file becomes part of the directory structure.
+
+**script-02.js**
+
+*The following script is almost identical to script-01.js, only the changed sections will be highlighted. Remember you can always refer to the complete version of the script in the examples repo.*
+
+```js
+
+import "dotenv/config"
+import { Bee, MantarayNode } from "@ethersphere/bee-js"
+import { printManifestJson } from './manifestToJson.js'
+
+const bee = new Bee(process.env.BEE_RPC_URL)
+const batchId = process.env.POSTAGE_BATCH_ID
+
+// We specify the manifest returned from script-01.js here
+const ROOT_MANIFEST = '4d5e6e3eb532131e128b1cd0400ca249f1a6ce5d4005c0b57bf848131300df9d'
+
+async function addFileToManifest() {
+    try {
+        // Load the generated manifest from script-01.js
+        const node = await MantarayNode.unmarshal(bee, ROOT_MANIFEST)
+        await node.loadRecursively(bee)
+
+        // File details for new file
+        const filename = 'new.txt'
+        const content = "Hi, I'm new here."
+        const bytes = new TextEncoder().encode(content)
+
+        // Upload raw file data 
+        // Note we use "bee.uploadData()", not "bee.uploadFile()", since we need the root reference hash of the content, not a manifest reference. 
+        const { reference } = await bee.uploadData(batchId, bytes)
+        console.log('Uploaded raw reference:', reference.toHex())
+
+        // Metadata must be a plain JS object — NOT a Map or Uint8Array
+        const metadata = {
+            'Content-Type': 'text/plain; charset=utf-8',
+            'Filename': filename,
+        }
+
+        // Insert the new file data into our new manifest
+        node.addFork(filename, reference, metadata)
+
+        // Save and print updated manifest
+        const newManifest = await node.saveRecursively(bee, batchId)
+        const newReference = newManifest.reference
+        console.log('Updated manifest hash:', newReference.toHex())
+        printManifestJson(node)
+
+        // Download new file and print its contents
+        const newFile = await bee.downloadFile(newReference, "new.txt")
+        console.log("new.txt:", newFile.data.toUtf8())
+
+    }
+    catch (error) {
+        console.error("Error during upload or download:", error.message)
+    }
+}
+
+addFileToManifest()
+```
+
+Terminal output:
+
+```bash
+noah@NoahM16:~/examples/manifests$ node script-02.js
+Uploaded raw reference: 3515db2f5e3c075b7546d7dd7dea1680c3e0785c6584e66b7e4f56fc344a0a78
+Updated manifest hash: 4f67218844a814655c8d81aae4c4286a142318d672113973360c33c7930ce2f5
+{
+    "path": "/",
+    "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "metadata": null,
+    "forks": {
+        "folder/": {
+            "path": "folder/",
+            "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "metadata": null,
+            "forks": {
+                "nested.txt": {
+                    "path": "nested.txt",
+                    "target": "0x9442e445c0d58adea58e0a8afcdcc28ed7642d7a4ff9a253e8f1595faafbb808",
+                    "metadata": {
+                        "Content-Type": "text/plain; charset=utf-8",
+                        "Filename": "nested.txt"
+                    },
+                    "forks": {}
+                },
+                "subfolder/deep.txt": {
+                    "path": "subfolder/deep.txt",
+                    "target": "0x6aa935879ad2a547e57ea6350338bd04ad758977b542e86b31c159f31834b8fc",
+                    "metadata": {
+                        "Content-Type": "text/plain; charset=utf-8",
+                        "Filename": "deep.txt"
+                    },
+                    "forks": {}
+                }
+            }
+        },
+        "root.txt": {
+            "path": "root.txt",
+            "target": "0x98e63f7e826a01634881874246fc873cdf06bb5409ff5f9ec61d1e2de1dd3bf6",
+            "metadata": {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Filename": "root.txt"
+            },
+            "forks": {}
+        },
+        "new.txt": {
+            "path": "new.txt",
+            "target": "0x3515db2f5e3c075b7546d7dd7dea1680c3e0785c6584e66b7e4f56fc344a0a78",
+            "metadata": {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Filename": "new.txt"
+            },
+            "forks": {}
+        }
+    }
+}
+new.txt: Hi, I'm new here.
+```
+
+This produces a new manifest where `/new.txt` is now accessible as a root level entry.
+
+### Moving a File to a Subfolder
+
+This script:
+
+1. Removes `/new.txt` from the manifest
+2. Adds it back under `/nested/deeper/new.txt`
+3. Prints the updated manifest
+
+**script-03.js**
+
+```js
+import "dotenv/config"
+import { Bee, MantarayNode } from "@ethersphere/bee-js"
+import { printManifestJson } from './manifestToJson.js'
+
+const bee = new Bee(process.env.BEERPC_URL || process.env.BEE_RPC_URL)
+const batchId = process.env.POSTAGE_BATCH_ID
+
+// Manifest returned from script-02.js
+const ROOT_MANIFEST = 'SCRIPT_2_MANIFEST'
+
+async function moveFileInManifest() {
+    try {
+        // Load manifest generated in script-02
+        const node = await MantarayNode.unmarshal(bee, ROOT_MANIFEST)
+        await node.loadRecursively(bee)
+
+        // Reload manifest to capture original file reference *before* deletion
+        const original = await MantarayNode.unmarshal(bee, ROOT_MANIFEST)
+        await original.loadRecursively(bee)
+
+        const existing = original.find("new.txt")
+        if (!existing) {
+            throw new Error("Could not retrieve file reference for new.txt — run script-02.js first.")
+        }
+
+        const fileRef = existing.targetAddress
+
+        // STEP 1 — Remove /new.txt
+        node.removeFork("new.txt")
+        console.log("Removed /new.txt from manifest.")
+
+        // STEP 2 — Re-add under /nested/deeper/new.txt
+        const newPath = "nested/deeper/new.txt"
+
+        node.addFork(
+            newPath,
+            fileRef,
+            {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Filename": "new.txt"
+            }
+        )
+
+        console.log(`Added file under /${newPath}`)
+
+        // STEP 3 — Save updated manifest
+        const updated = await node.saveRecursively(bee, batchId)
+        const newManifestRef = updated.reference.toHex()
+
+        console.log("Updated manifest hash:", newManifestRef)
+
+        // STEP 4 — Print JSON
+        printManifestJson(node)
+
+        // STEP 5 — Download the file from its new location and print contents
+        const downloaded = await bee.downloadFile(updated.reference, newPath)
+        console.log(`\nContents of /${newPath}:`)
+        console.log(downloaded.data.toUtf8())
+
+    } catch (error) {
+        console.error("Error while modifying manifest:", error.message)
+    }
+}
+
+moveFileInManifest()
+```
+
+Terminal output:
+
+```bash
+user@machine:~/examples/manifests$ node script-03.js
+Removed /new.txt from manifest.
+Added file under /nested/deeper/new.txt
+Updated manifest hash: 656ea924fb4d98b7fa327eb9e4d98ece6c2f4370515d23b40dfca71bc99a08a6
+{
+    "path": "/",
+    "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "metadata": null,
+    "forks": {
+        "folder/": {
+            "path": "folder/",
+            "target": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "metadata": null,
+            "forks": {
+                "nested.txt": {
+                    "path": "nested.txt",
+                    "target": "0x9442e445c0d58adea58e0a8afcdcc28ed7642d7a4ff9a253e8f1595faafbb808",
+                    "metadata": {
+                        "Content-Type": "text/plain; charset=utf-8",
+                        "Filename": "nested.txt"
+                    },
+                    "forks": {}
+                },
+                "subfolder/deep.txt": {
+                    "path": "subfolder/deep.txt",
+                    "target": "0x6aa935879ad2a547e57ea6350338bd04ad758977b542e86b31c159f31834b8fc",
+                    "metadata": {
+                        "Content-Type": "text/plain; charset=utf-8",
+                        "Filename": "deep.txt"
+                    },
+                    "forks": {}
+                }
+            }
+        },
+        "root.txt": {
+            "path": "root.txt",
+            "target": "0x98e63f7e826a01634881874246fc873cdf06bb5409ff5f9ec61d1e2de1dd3bf6",
+            "metadata": {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Filename": "root.txt"
+            },
+            "forks": {}
+        },
+        "nested/deeper/new.txt": {
+            "path": "nested/deeper/new.txt",
+            "target": "0x3515db2f5e3c075b7546d7dd7dea1680c3e0785c6584e66b7e4f56fc344a0a78",
+            "metadata": {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Filename": "new.txt"
+            },
+            "forks": {}
+        }
+    }
+}
+
+Contents of /nested/deeper/new.txt:
+Hi, I'm new here.
+```
+
+
+Now the file appears under:
+
+```
+/nested/deeper/root.txt
+```
+
+Note that the only new method we used was `node.removeFork()` to remove the entry from the manifest.
+
+
diff --git a/docs/develop/routing.md b/docs/develop/routing.md
new file mode 100644
index 00000000..aaa8519c
--- /dev/null
+++ b/docs/develop/routing.md
@@ -0,0 +1,396 @@
+---
+title: Website Routing
+id: routing
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+Add intro and transition, mention different types of routing and strengths and weaknesses.
+-----------------
+
+## Client-Side Hash Routing 
+
+This section explains how to add hash based client side routing to your Swarm hosted site so that you can have clean URLs for each page of your website. See the [routing project in the examples repo](https://github.com/ethersphere/examples/tree/main/routing) for a full working example implementation.
+
+### Why Hash Based Client Side Routing?
+
+Swarm does not behave like a traditional web server — there is **no server-side routing**, and every route must correspond to a real file inside the site manifest.
+If you try to use typical "clean URLs" like:
+
+```bash
+/about
+/contact
+/dashboard/settings
+```
+
+Swarm will look for literal files such as:
+
+```bash
+about
+contact
+dashboard/settings
+```
+
+...which obviously don’t exist unless you manually manipulate the manifest.
+This is theoretically possible, but is tricky and complex to do manually, and there is currently not (yet) any tooling to make it easier.
+
+### How to Add Routing
+
+If you want multiple pages on a Swarm-hosted website, you should use a client-side router. Swarm has no server backend running code and so can’t rewrite paths, so we use **React Router’s `HashRouter`**, which keeps all routing inside the browser.
+
+Below is the simplest way to set this up using **create-swarm-app** and then adding your own pages.
+
+
+#### 1. Create a New Vite + React Project (with `create-swarm-app`)
+
+Run:
+
+```bash
+npm init swarm-app@latest my-dapp-new vite-tsx
+```
+
+This generates a clean project containing:
+
+```bash
+src/
+  App.tsx
+  index.tsx
+  config.ts
+public/
+index.html
+package.json
+```
+
+You now have a fully working Vite/React app ready for Swarm uploads.
+
+
+#### 2. Install React Router
+
+Inside the project:
+
+```bash
+npm install react-router-dom
+```
+
+This gives you client-side navigation capability.
+
+
+
+#### 3. Switch the App to Use Hash-Based Routing
+
+Swarm only serves literal files, so `/#/about` is the only reliable way to have “pages.”
+
+Replace your `App.tsx` with:
+
+```tsx
+import { HashRouter, Routes, Route, Link } from 'react-router-dom'
+import { Home } from './Home'
+import { About } from './About'
+import { NotFound } from './NotFound'
+
+export function App() {
+    return (
+        <HashRouter>
+            <nav style={{ display: 'flex', gap: '12px', padding: '12px' }}>
+                <Link to="/">Home</Link>
+                <Link to="/about">About</Link>
+            </nav>
+
+            <Routes>
+                <Route path="/" element={<Home />} />
+                <Route path="/about" element={<About />} />
+                <Route path="*" element={<NotFound />} />
+            </Routes>
+        </HashRouter>
+    )
+}
+```
+
+This gives you usable routes:
+
+```bash
+/#/         → Home
+/#/about    → About
+/#/anything → React 404 page
+```
+
+#### 4. Add Your Page Components
+
+Example `Home.tsx`:
+
+```tsx
+export function Home() {
+  return (
+    <div style={{ padding: '20px' }}>
+      <h1>Home</h1>
+      <p>Welcome to your Swarm-powered app.</p>
+    </div>
+  )
+}
+```
+
+Example `About.tsx`:
+
+```tsx
+export function About() {
+  return (
+    <div style={{ padding: '20px' }}>
+      <h1>About</h1>
+      <p>This demo shows how to upload files or directories to Swarm using Bee-JS.</p>
+    </div>
+  )
+}
+```
+
+Example `NotFound.tsx`:
+
+```tsx
+export function NotFound() {
+  return (
+    <div style={{ padding: '20px' }}>
+      <h1>Page Not Found</h1>
+      <a href="./#/">Return to Home</a>
+    </div>
+  )
+}
+```
+
+#### 5. Add a Static `404.html` for Non-Hash URLs
+
+Swarm still needs a fallback for URLs like:
+
+```
+/non-existent-file
+```
+
+Create `public/404.html`:
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8" />
+  <title>404 – Not Found</title>
+  <style>
+    body { font-family: sans-serif; padding: 40px; }
+    a { color: #007bff; }
+  </style>
+</head>
+
+<nav style="display: flex; gap: 12px; padding: 12px">
+  <a href="./#/">Home</a>
+  <a href="./#/about">About</a>
+</nav>
+
+<body>
+  <h1>404</h1>
+  <p>This page doesn't exist.</p>
+  <p><a href="./#/">Return to Home</a></p>
+</body>
+</html>
+```
+
+Vite will automatically include this in `dist/`.
+
+This file handles **non-hash** missing paths.
+React handles **hash** missing paths.
+
+
+#### 6. Build the Project
+
+Before uploading, compile the Vite app into a static bundle:
+
+```bash
+npm run build
+```
+
+This produces a `dist/` folder containing:
+
+```bash
+dist/
+  index.html
+  404.html
+  assets/
+```
+
+Everything inside `dist/` will be uploaded to your Swarm feed.
+
+#### 7. Create a Publisher Identity and Deploy Using a Feed Manifest 
+
+For stable URLs, use a **feed manifest** reference. This gives you a permanent Swarm URL that always resolves to the latest version of your content.
+
+Create an identity (if you don’t have one yet):
+
+```bash
+swarm-cli identity create web-publisher
+```
+
+Upload your built site to the feed:
+
+<Tabs>
+    <TabItem value="linux" label="Linux / macOS">
+
+    ```bash
+    swarm-cli feed upload ./dist \
+    --identity web-publisher \
+    --topic-string website \
+    --stamp <BATCH_ID> \
+    --index-document index.html \
+    --error-document 404.html
+    ```
+    </TabItem>
+    
+    <TabItem value="powershell" label="Windows PowerShell">
+
+    ```bash
+    swarm-cli feed upload .\dist `
+    --identity web-publisher `
+    --topic-string website `
+    --stamp 3d98a22f522377ae9cc2aa3bca7f352fb0ed6b16bad73f0246b0a5c155f367bc `
+    --index-document index.html `
+    --error-document 404.html
+
+    ```
+    </TabItem>
+</Tabs>
+
+
+The output includes:
+
+* the **content hash**
+* the **feed manifest URL** → this is your **permanent website URL**
+* stamp usage details
+
+Example:
+
+```bash
+Feed Manifest URL:
+http://localhost:1633/bzz/<feed-manifest-hash>/
+```
+
+This URL never changes, even when you update your site.
+
+
+#### 8. Visit Your Site
+
+* Home:
+  `/#/`
+
+* About:
+  `/#/about`
+
+* Invalid hash route: handled by `NotFound.tsx`
+
+* Invalid non-hash route: handled by `404.html`
+
+#### Summary
+
+You now have:
+
+* A Vite + React app
+* Hash-based routing fully compatible with Swarm
+* A static 404 for non-hash paths
+* A React 404 for invalid hash paths
+* Stable, versioned deployments using feed manifests
+
+## Add transition here
+
+## Website Routing 
+
+#### 1. Upload the Site (and Observe Basic Behavior)
+
+Start by uploading the site:
+
+```ts
+const { reference } = await bee.uploadFilesFromDirectory(batchId, './site')
+```
+
+Without manifest edits, routes only work via exact file paths like:
+
+```
+/index.html
+/about.html
+/contact.html
+```
+
+Trying to access `/about` or `/about/` will fail.
+
+#### 2. Fix Routing With Manifest Manipulation
+
+You can fix clean URLs using **two strategies**:
+
+##### Strategy A: Add Aliases to the Manifest
+
+```ts
+node.addFork('about', referenceForAbout, metadata)
+node.addFork('about/', referenceForAbout, metadata)
+```
+
+Now `/about` and `/about/` work like `/about.html`.
+
+##### Strategy B: Use Directory Index Files
+
+Restructure files like:
+
+```
+/about/index.html
+/contact/index.html
+```
+
+And add them to the manifest like:
+
+```ts
+node.addFork('about/', referenceForAboutIndex, metadata)
+```
+
+This gives you full directory-style clean URLs.
+
+#### 3. Removal and Redirect
+
+To "delete" a page you would need to remove all entries for it from the manifest to remove it entirely:
+
+```js
+node.removeFork('old-page.html')
+```
+For example, if you had manually added:
+
+```js
+node.addFork('about', referenceForAbout, metadata)
+node.addFork('about/', referenceForAbout, metadata)
+```
+
+You will need to make sure to fully remove all entries for that file from the manifest to really "delete" it from your site.
+
+```js
+node.removeFork('about')
+node.removeFork('about/')
+node.removeFork('about.html')
+```
+
+:::info 
+The file is not removed from the Swarm network since data on Swarm is immutable. Anyone who has its reference can still retrieve it. Removing it from your manifest just means it's no longer available through a route on your site.
+:::
+
+
+We are adding a record with the same path but now pointing at new content to achieve "redirect" like behavior.
+
+To redirect:
+
+```js
+node.addFork('old-page.html', newPageReference, metadata)
+```
+
+This lets you “deprecate” a page and point old paths to new ones.
+
+#### 4. Manifest Routing Enables Dynamic Content
+
+Once you understand manifest-based routing, you can dynamically:
+
+* Add new paths (e.g. blog posts, product pages)
+* Create custom routes
+* Redirect old paths
+* 
+
+Next, learn how manifest manipulation plays a key role in enabling the [dynamic content](/docs/develop/dynamic-content) on Swarm. It will allow you to turn Swarm into a decentralized CMS and decouple your front end from your back end.
+
diff --git a/docs/develop/tools-and-features/feeds.md b/docs/develop/tools-and-features/feeds.md
index ce09ede3..e41f0f8e 100644
--- a/docs/develop/tools-and-features/feeds.md
+++ b/docs/develop/tools-and-features/feeds.md
@@ -38,12 +38,4 @@ Swarm's feeds provide the ability to update your immutable content in a mutable
 
 ### Use Cases for Feeds
 
-Feeds are a hugely versatile data structure.
-
-#### Key Value Store
-
-Use [bee-js](/docs/develop/tools-and-features/bee-js) to use feeds to store values as a simple key value store in your JavaScript application. No more need for servers and databases!
-
-#### Store the History of a File
-
-Use [swarm-cli](/docs/bee/working-with-bee/swarm-cli) to store a file at the same location, and update whenever you like without changing the address.
+Feeds are a hugely versatile data structure. They allow you to host frequently updated content such as websites, RSS feeds (for podcasts, news, etc.), or even a DNS style architecture on top of Swarm's decentralized DISC. 
diff --git a/docs/references/awesome-list.mdx b/docs/references/awesome-list.mdx
index 7498f269..1362e36a 100644
--- a/docs/references/awesome-list.mdx
+++ b/docs/references/awesome-list.mdx
@@ -22,16 +22,16 @@ Click on the menu icon next to [README.md](#readme) for a list of sections
 
 **[`^ back to top ^`](#)**
 
-[Bee](https://github.com/ethersphere/bee) - Also referred to as the _node_ or the _client_, this service allows you to join the Swarm network
+[Bee](https://github.com/ethersphere/bee) - Also referred to as the _node_ or the _client_, this service allows you to join the Swarm network.
 
 
 ### Libraries
 
 **[`^ back to top ^`](#)**
 
-[Bee-JS](https://github.com/ethersphere/bee-js) - A high-level Javascript library to interact with Bee through its REST API
+[Bee-JS](https://github.com/ethersphere/bee-js) - A high-level Javascript library to interact with Bee through its REST API.
 
-[Mantaray-js](https://github.com/ethersphere/mantaray-js) - A low-level Swarm manifest manipulation library
+[Mantaray-js](https://github.com/ethersphere/mantaray-js) - A low-level Swarm manifest manipulation library.
 
 [Mantaray-py](https://github.com/Ankvik-Tech-Labs/mantaray-py/) - Allows you to manipulate and interpret mantaray data via MantarayNode and MantarayFork abstractions.
 
@@ -39,7 +39,7 @@ Click on the menu icon next to [README.md](#readme) for a list of sections
 
 **[`^ back to top ^`](#)**
 
-[Beekeeper](https://github.com/ethersphere/beekeeper) - Orchestrate and test Bee clusters through Kubernetes
+[Beekeeper](https://github.com/ethersphere/beekeeper) - Orchestrate and test Bee clusters through Kubernetes.
 
 [Swarm Actions](https://github.com/ethersphere/swarm-actions) - GitHub Actions workflow for uploading data to the Swarm network.  
 
@@ -47,9 +47,9 @@ Click on the menu icon next to [README.md](#readme) for a list of sections
 
 **[`^ back to top ^`](#)**
 
-[Bee Dashboard](https://github.com/ethersphere/bee-dashboard) - React project to troubleshoot and interact with your Bee node
+[Bee Dashboard](https://github.com/ethersphere/bee-dashboard) - React project to troubleshoot and interact with your Bee node.
 
-[Gateway](https://github.com/ethersphere/gateway) - Gateway to the Swarm project, for uploading, downloading and sharing assets on the network
+[Gateway](https://github.com/ethersphere/gateway) - Gateway to the Swarm project, for uploading, downloading and sharing assets on the network.
 
 [Swarmy](https://swarmy.cloud/) - Swarm as a service, makes it simple to store and retrieve data on Swarm. 
 
@@ -65,17 +65,19 @@ Click on the menu icon next to [README.md](#readme) for a list of sections
 
 **[`^ back to top ^`](#)**
 
-[Swarm CLI](https://github.com/ethersphere/swarm-cli) - Do everything on Swarm with the power of the terminal
+[Swarm MCP](https://github.com/ethersphere/swarm-mcp) - A Model Context Protocol (MCP) server implementation that uses Ethereum Swarm's Bee API for storing and retrieving data.
 
-[Swarm Extension](https://github.com/ethersphere/swarm-extension) - Official extension that adds Swarm support and injects Bee library to the browser
+[Swarm CLI](https://github.com/ethersphere/swarm-cli) - No more copy-pasting curl commands, with `swarm-cli` you can do everything on Swarm with simple commands straight from the terminal.
+
+[Swarm Extension](https://github.com/ethersphere/swarm-extension) - Official extension that adds Swarm support and injects Bee library to the browser.
 
 [Swarm CID Converter](https://github.com/agazso/swarm-cid-converter) - Convert Swarm hashes or links to CID and vice versa.
 
-[Bee-AFS](https://github.com/aloknerurkar/bee-afs) - FUSE filesystem for Bee
+[Bee-AFS](https://github.com/aloknerurkar/bee-afs) - FUSE filesystem for Bee.
 
 [Nextcloud Swarm Plugin](https://github.com/MetaProvide/nextcloud-swarm-plugin) - Plugin for bridging Nextcloud and Swarm.
 
-[Beest](https://github.com/w3rkspacelabs/beest) -  An interactive CLI toolkit that simplifies the management of multiple Bee nodes
+[Beest](https://github.com/w3rkspacelabs/beest) -  An interactive CLI toolkit that simplifies the management of multiple Bee nodes.
 
 [Doctor Bee](https://github.com/w3rkspacelabs/doctor-bee) - A simple python script to check up a Bee node's health status.
 
@@ -85,15 +87,15 @@ Click on the menu icon next to [README.md](#readme) for a list of sections
 
 **[`^ back to top ^`](#)**
 
-[Swap, Swear and Swindle](https://github.com/ethersphere/swap-swear-and-swindle) - Protocols for peer-to-peer accounting
+[Swap, Swear and Swindle](https://github.com/ethersphere/swap-swear-and-swindle) - Protocols for peer-to-peer accounting.
 
-[Storage Incentives](https://github.com/ethersphere/storage-incentives) - Smart contracts providing the basis for Swarm's storage incentivization model
+[Storage Incentives](https://github.com/ethersphere/storage-incentives) - Smart contracts providing the basis for Swarm's storage incentivization model.
 
 ### Documentation
 
 **[`^ back to top ^`](#)**
 
-[The Book of Swarm](https://docs.ethswarm.org/the-book-of-swarm.pdf) - Storage and communication infrastructure for self-sovereign digital society back-end stack for the decentralised web
+[The Book of Swarm](https://docs.ethswarm.org/the-book-of-swarm.pdf) - Storage and communication infrastructure for self-sovereign digital society back-end stack for the decentralised web.
 
 [Bee Docs](https://github.com/ethersphere/bee-docs) - Documentation for the Swarm Bee Client. View at [docs.ethswarm.org](https://docs.ethswarm.org/docs/).
 
@@ -112,27 +114,27 @@ Click on the menu icon next to [README.md](#readme) for a list of sections
 
 **[`^ back to top ^`](#)**
 
-[Fair data society](https://fairdatasociety.org/) - Ecosystem initiative for ethical Web3
+[Fair data society](https://fairdatasociety.org/) - Ecosystem initiative for ethical Web3.
 
-[FairOS](https://github.com/fairDataSociety/fairOS-dfs) - Distributed file system, key-value store and nosql store on Swarm (for developers)
+[FairOS](https://github.com/fairDataSociety/fairOS-dfs) - Distributed file system, key-value store and nosql store on Swarm (for developers).
 
 [The Fair Data Protocol (FDP)](https://fdp.fairdatasociety.org/) - A data interoperability protocol for dApps that use personal data.
  
-[FDP play](https://github.com/fairDataSociety/fdp-play) - CLI tool to spin up local development FDP environment and Bee cluster with Docker
+[FDP play](https://github.com/fairDataSociety/fdp-play) - CLI tool to spin up local development FDP environment and Bee cluster with Docker.
 
-[Fairdrive](https://fairdrive.fairdatasociety.org/) - Decentralised and unstoppable "Dropbox" for end-users and developers using Fair Data Protocol
+[Fairdrive](https://fairdrive.fairdatasociety.org/) - Decentralised and unstoppable "Dropbox" for end-users and developers using Fair Data Protocol.
 
-[Fairdrive code](https://github.com/fairDataSociety/fairdrive-theapp) - Code for decentralised and unstoppable "Dropbox" for end-users and developers using Fair Data Protocol
+[Fairdrive code](https://github.com/fairDataSociety/fairdrive-theapp) - Code for decentralised and unstoppable "Dropbox" for end-users and developers using Fair Data Protocol.
 
-[Galileo](https://app.galileo.fairdatasociety.org/) - Open Street Maps on Swarm
+[Galileo](https://app.galileo.fairdatasociety.org/) - Open Street Maps on Swarm.
 
-[SwarmScan](https://swarmscan.resenje.org/) - Get network insights
+[SwarmScan](https://swarmscan.resenje.org/) - Get network insights.
 
-[Etherna.io](https://etherna.io/) - Decentralised media platform on Swarm
+[Etherna.io](https://etherna.io/) - Decentralised media platform on Swarm.
 
-[SwarmNFT library](https://github.com/igar1991/SwarmNFT) - JavaScript library for creating NFTs on Ethereum-compatible blockchains and storing content on Swarm
+[SwarmNFT library](https://github.com/igar1991/SwarmNFT) - JavaScript library for creating NFTs on Ethereum-compatible blockchains and storing content on Swarm.
 
-[videoNFT](https://github.com/pabloVoorvaart/videoNFT/) - NFT live streaming with Swarm (winner of EthBerlin3 2022 Freedom to Transact Track)
+[videoNFT](https://github.com/pabloVoorvaart/videoNFT/) - NFT live streaming with Swarm (winner of EthBerlin3 2022 Freedom to Transact Track).
 
 [DeBoot](https://github.com/awmacpherson/deboot) - DeBoot is a project to research and implement approaches to bootloading OS images from a decentralized storage network such as Swarm or IPFS.
 
@@ -150,9 +152,10 @@ Click on the menu icon next to [README.md](#readme) for a list of sections
 
 **[`^ back to top ^`](#)**
 
-[Swarm Bot](https://github.com/ethersphere/swarm-bot) - Discord bot handling commands related to Swarm and its community
+[Swarm Bot](https://github.com/ethersphere/swarm-bot) - Discord bot handling commands related to Swarm and its community.
 
 [ethersphere/bee DeepWiki](https://deepwiki.com/ethersphere/bee) - The DeepWiki for the Bee client GitHub repository. DeepWiki is a tool which provides autogenerated documentation (using LLM ai agents such as ChatGPT or Google Gemini) based directly on code from a GitHub repository. It also has a question box where any question can be asked about the Bee codebase.
 
 
 *As with all LLMs, DeepWiki may sometimes be confidently wrong. Make sure to always double check (either by inspecting the code yourself, or confirming with a Bee team core developer) before assuming its answers are correct.*
+
diff --git a/docusaurus.config.js b/docusaurus.config.js
index 09b119e0..d1c3131e 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -201,10 +201,6 @@ module.exports = {
               to: 'docs/develop/introduction',
               label: 'Getting Started'
             },  
-            {
-              to: 'docs/develop/introduction',
-              label: 'Building on Swarm'
-            },
             {
               to: 'docs/develop/tools-and-features/introduction',
               label: 'Tools and Features'
diff --git a/sidebars.js b/sidebars.js
index 4cb5ace7..421729d7 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -90,6 +90,9 @@ module.exports = {
         'develop/introduction',
         'develop/upload-and-download',
         'develop/host-your-website',
+        'develop/manifests',
+        'develop/routing',        
+        'develop/dynamic-content',
         'develop/act',
       ],
       collapsed: false