Build a Digital Garden

A digital garden is a personal knowledge space that grows over time. Unlike a blog — where posts are finished and dated — a digital garden is a collection of living notes that evolve, link to each other, and form an interconnected web of ideas.

In this guide you will:

• Create a garden vault to hold your notes
• Write notes with wikilinks that connect related ideas
• Explore backlinks to see which notes reference a given page
• Visualise your garden as a document graph
• Selectively publish mature notes while keeping drafts private
• Share individual notes as private links for feedback

The key mindset shift: stop thinking of notes as finished articles and start thinking of them as seeds that grow richer as you add connections.

Create a dedicated vault for your garden. Keeping it separate from other vaults means you can publish it independently and control its navigation structure.

Via the UI: open Settings → Vaults → New Vault, enter a name (e.g. My Garden) and a slug (e.g. my-garden), then click Create.

Or use the SDK or CLI:

import { LifestreamVaultClient } from '@lifestreamdynamics/vault-sdk';

const { client } = await LifestreamVaultClient.login(
  'https://vault.lifestreamdynamics.com',
  'you@example.com',
  'your-password',
);

// The slug is generated from the name — you do not pass it.
const vault = await client.vaults.create({
  name: 'My Garden',
});

console.log('Garden vault created:', vault.id, '— slug:', vault.slug);

A Note on Structure

Digital gardens are intentionally less structured than documentation sites. Rather than imposing a rigid folder hierarchy upfront, let structure emerge from your links and tags. Some gardeners keep everything flat; others use a few broad categories like concepts/, projects/, and references/. Either approach works.

Wikilinks are the core mechanism that makes a digital garden feel alive. Use double-bracket syntax to reference another note from within any document:

[[note-slug]]

Lifestream Vault resolves wikilinks by matching the text inside the brackets against document slugs (derived from file paths). A wikilink like [[zettelkasten]] automatically becomes a clickable link to zettelkasten.md in your vault.

You can also provide display text using a pipe:

[[zettelkasten|the Zettelkasten method]]

Here is an example note that uses wikilinks naturally:

---
title: Note-Taking Systems
tags: [productivity, knowledge-management]
---

# Note-Taking Systems

There are many approaches to capturing and organising knowledge.
The [[zettelkasten]] method focuses on atomic, interconnected notes.
[[gtd|Getting Things Done]] is more task-oriented.

For a comparison, see [[pkm-comparison]].

Unresolved Wikilinks

If a wikilink points to a document that does not yet exist, it renders as a broken link styled differently from resolved links. This is intentional — broken wikilinks are a todo list for notes you haven't written yet. Use client.vaults.getUnresolvedLinks() to find all of them programmatically (see the Tips section).

Backlinks tell you which other notes in your vault link to the current note. They are the reverse of wikilinks — rather than asking "what does this note link to?", backlinks answer "what notes link here?"

In the web editor, backlinks appear automatically in the sidebar under Linked References whenever you open a document that has incoming links.

You can also query backlinks programmatically:

// getBacklinks is positional: (vaultId, docPath) — pass the document path
const backlinks = await client.documents.getBacklinks(vault.id, 'zettelkasten.md');

console.log(`Found ${backlinks.length} backlinks:`);
for (const link of backlinks) {
  console.log(` - ${link.sourceDocument.path}: "${link.contextSnippet ?? link.linkText}"`);
}

Using Backlinks to Grow Your Garden

The most productive use of backlinks is discovering unexpected connections. When you notice that two unrelated notes both link to a third note, that third note is probably an important concept worth developing further. It may deserve its own deeper treatment, or it may reveal a gap in your thinking.

A note with many incoming backlinks is a hub — a central concept that shows up across many areas of your knowledge. Hub notes are good candidates for the evergreen tag (see Tips).

The vault graph is a force-directed visualisation of every document and every link between documents. Each node is a note; each edge is a wikilink. Clusters of tightly connected nodes reveal areas of deep interest; isolated nodes reveal notes that haven't been connected to the broader garden yet.

Open the graph in the web UI by clicking the Graph icon in the vault toolbar.

You can also fetch the raw graph data and build your own visualisation:

// Fetch the full vault graph (nodes + edges) — getGraph(vaultId) is positional
const graph = await client.vaults.getGraph(vault.id);

console.log('Nodes:', graph.nodes.length);
console.log('Edges:', graph.edges.length);

// Find the most connected nodes (highest degree)
const degree = new Map<string, number>();
for (const edge of graph.edges) {
  degree.set(edge.source, (degree.get(edge.source) ?? 0) + 1);
  degree.set(edge.target, (degree.get(edge.target) ?? 0) + 1);
}

const sorted = [...degree.entries()]
  .sort((a, b) => b[1] - a[1])
  .slice(0, 10);

console.log('Top 10 most-connected notes:');
for (const [nodeId, connections] of sorted) {
  const node = graph.nodes.find((n) => n.id === nodeId);
  console.log(` - ${node?.path ?? nodeId}: ${connections} connections`);
}

One of the defining features of a digital garden is progressive publishing — the idea that you share notes as they mature rather than waiting until they're "done". Notes can exist in different states of development:

Use a status frontmatter field to track maturity:

---
title: Zettelkasten
status: evergreen
tags: [knowledge-management, productivity]
---

When a note reaches evergreen status, publish it using the SDK or CLI to make it publicly accessible:

// publish.create is positional: (vaultId, documentPath, params)
const published = await client.publish.create(
  vault.id,
  'zettelkasten.md',
  {
    slug: 'zettelkasten',
    seoTitle: 'Zettelkasten — My Garden',
    seoDescription:
      'My notes on the Zettelkasten method for networked note-taking.',
  },
);

// The public URL is your profile slug + the post slug:
//   https://vault.lifestreamdynamics.com/{profileSlug}/{published.slug}
console.log('Published with slug:', published.slug);

// To unpublish (make private again) — delete(vaultId, documentPath)
await client.publish.delete(vault.id, 'zettelkasten.md');

// List all currently published documents in your garden — listMine(vaultId)
const publishedDocs = await client.publish.listMine(vault.id);
console.log(`${publishedDocs.length} notes are publicly visible`);

Sometimes you want to share a note with a specific person for feedback — without publishing it publicly. Share links generate a unique URL that grants read access to a single document without requiring the recipient to have a Lifestream Vault account.

Share links can be:

• Open — anyone with the link can read the document
• Password-protected — the recipient must enter a password to unlock the note (Pro tier)
• Expiring — automatically revoke access after a specified date

// shares.create is positional: (vaultId, documentPath, options).
// The full token is returned only at creation time.
const open = await client.shares.create(vault.id, 'zettelkasten.md', {
  permission: 'view',
});

console.log('Share URL:', `https://vault.lifestreamdynamics.com/share/${open.fullToken}`);

// Create a password-protected, expiring share link (Pro tier)
const protectedLink = await client.shares.create(vault.id, 'zettelkasten.md', {
  permission: 'view',
  password: 'garden2026',
  expiresAt: new Date('2026-04-01').toISOString(),
});

console.log('Protected share URL:', `https://vault.lifestreamdynamics.com/share/${protectedLink.fullToken}`);

// Revoke a share link — revoke(vaultId, shareId)
await client.shares.revoke(vault.id, open.shareLink.id);

Atomic Notes

Write one idea per note. Atomic notes are easier to link, easier to find, and easier to evolve over time. If a note is getting long, it's probably two notes trying to be one.

Evergreen Notes

An evergreen note is written to stand on its own and remain relevant indefinitely. Avoid time-dependent phrases like "recently" or "last week" in evergreen notes — they age poorly. Instead, write "as of 2026" if the date matters.

Consistent Naming

Use lowercase, hyphen-separated slugs that describe the concept clearly:

• Good: zettelkasten.md, opportunity-cost.md, spaced-repetition.md
• Avoid: ZK.md, My Thoughts on X.md, temp.md

Clear names make wikilinks readable in context and keep the graph legible.

Finding Broken Links

Use the SDK to find all wikilinks that point to documents that don't exist yet. These are your writing backlog:

// getUnresolvedLinks(vaultId) is positional and returns UnresolvedLink[]
const unresolved = await client.vaults.getUnresolvedLinks(vault.id);

console.log('Unresolved wikilinks (notes to write):');
for (const link of unresolved) {
  // Each entry has a targetPath plus the references that point to it
  const sources = link.references.map((r) => r.sourcePath).join(', ');
  console.log(` - "${link.targetPath}" (referenced from ${sources})`);
}

Garden Tending

Set aside regular time (weekly or monthly) to:

1. Review recently created notes and add wikilinks
2. Look at isolated nodes in the graph and connect them
3. Resolve broken wikilinks by writing the missing note
4. Upgrade budding notes to evergreen status when ready

Tags vs Links

• Use tags (tags: [productivity]) to categorise notes by topic — they power filtered views in the published vault
• Use wikilinks for specific conceptual relationships — they build the graph and drive backlinks
• Both complement each other; neither replaces the other

Your digital garden is now ready to grow. Here are some directions to take it further:

• SDK Documents Reference — full API surface for client.documents, including getBacklinks(), get(), and bulk operations
• SDK Vaults Reference — client.vaults.getGraph(), getUnresolvedLinks(), and vault-level settings
• Build a Documentation Site — if your garden evolves into structured product documentation
• Create a Blog — publish polished, dated posts alongside your evergreen notes
• Sharing & Publishing Reference — advanced share link configuration, expiry, analytics, and password management
• Automate Your Vault — fire events when notes are published, so you can notify followers or trigger automation