# Getting Started

## What is Yando?

Yando is a collaborative whiteboard application for teams. Create boards with sticky notes, text boxes, and shapes, then organize them using templates like Business Model Canvas and SWOT Analysis. Multiple users can collaborate in real time with live cursors and object locking.

## Creating an Account

1. Click **Sign Up** in the top-right corner
2. Enter your email address and password
3. You'll be logged in automatically

Your account comes with a randomly assigned avatar color used for presence indicators when collaborating.

## The Dashboard

After signing in, you'll see the **Boards** page with two sections:

- **My Boards** - Boards you own and have full control over
- **Shared with Me** - Boards other users have invited you to collaborate on

From the top navigation, you can also access:

- **Projects** - Group related boards and markdown pages together
- **Templates** - Browse and create board templates
- **Docs** - This documentation

## Your First Board

1. Click **New Board** on the Boards page
2. Enter a title and optional description
3. Optionally select a template (e.g., Business Model Canvas)
4. Click **Create Board**

You'll be taken to the board canvas where you can start adding objects.

## Quick Shortcuts

Once on a board, use these keyboard shortcuts to get started fast:

| Shortcut | Action |
|----------|--------|
| **N** | Create a sticky note at the center of the viewport |
| **T** | Create a text box at the center of the viewport |
| **?** | Show all keyboard shortcuts |
| **Ctrl+1** | Fit all objects in view |

Both **N** and **T** immediately enter edit mode - type your text and press **Escape** to finish.

## Themes

Yando supports light and dark mode. Toggle the theme from:

- **Logged in**: Click your avatar in the top-right corner, then select "Dark Mode" or "Light Mode"
- **Not logged in**: Click the sun/moon icon in the top-right corner

Your theme preference is saved and synced across devices when logged in.


---

# Creating & Managing Boards

## Creating a Board

1. Navigate to **Boards** from the top navigation
2. Click **New Board**
3. Fill in the form:
   - **Title** (required) - Name for your board
   - **Description** (optional) - A short description
   - **Template** (optional) - Select a template to pre-populate zones
4. Click **Create Board**

### Creating from a Template

You can pre-select a template by clicking **Create Board** from a template's detail page or by browsing templates and selecting one. The board will be created with the template's zones pre-configured.

### Creating from JSON Import

On the board creation form, you can upload a JSON file exported from another board:

1. Click **Choose File** under the JSON import section
2. A preview shows the title, template, and object count
3. The title and description fields are pre-populated from the JSON
4. You can override the template if the original isn't available
5. Click **Create Board** to import

See [Export & Import](/docs/export-import/) for details on the JSON format.

## Editing a Board

From the board list page, click the **Edit** button on any board you own. You can change:

- Title and description
- Template (with intelligent object remapping)

### Changing Templates

When you change a board's template, objects are remapped to new zones using two strategies:

1. **Name matching** - Zones with the same name keep their objects
2. **Position-based fallback** - Remaining objects are assigned based on their position

If the canvas size changes significantly (>5%), object positions are scaled proportionally.

## Duplicating a Board

Click the **Duplicate** button on any board you own or are a member of:

1. A modal appears with the board's title (prefixed with "Copy of")
2. Optionally select a different template
3. Click **Duplicate**

All objects (sticky notes, text boxes, shapes) are copied with fresh UUIDs. If you choose a different template, zone remapping applies.

## Deleting a Board

Only board owners can delete boards:

1. Click **Delete** on the board card
2. Confirm the deletion in the dialog

This action is permanent and cannot be undone.

## Board Canvas

On the board canvas, you can:

- **Add objects**: Press N (sticky note), T (text box), or use the toolbar
- **Move objects**: Click and drag
- **Edit text**: Double-click a sticky note or text box
- **Resize objects**: Drag the corner handles
- **Rotate objects**: Use the rotation controls in the toolbar
- **Lock objects**: Select an object and click **Lock** so it can't be moved or edited by accident (see *Locked Objects* in [Real-Time Collaboration](/docs/collaboration/))
- **Delete objects**: Select and press Delete/Backspace
- **Pan the canvas**: Hold Shift and drag, or scroll with two fingers on a trackpad
- **Zoom**: Mouse wheel or pinch, or use the zoom buttons in the bottom-right
- **Fit to content**: Press Ctrl+1 to zoom to fit all objects
- **Search**: Press Ctrl+F to find objects by text or type

The dashed line marks the edge of the board's canvas. It grows by itself to hold everything on the board: when you (or an AI assistant over MCP) place something past the edge, and when the board's template gains zones or grows — boards you have open update straight away. It never shrinks by itself; **Shrink to fit** in the zoom panel trims unused space (on template boards, from the right and bottom only, so notes stay in their zones).


---

# Templates & Zones

## What are Templates?

Templates define zones (labeled regions) on a board's canvas. When you create a board with a template, objects are automatically organized into the zone they're placed in. This is useful for frameworks like Business Model Canvas, SWOT Analysis, and custom layouts.

A template can also include **scaffold objects** — titles, helper text, example sticky notes, frames, divider lines and arrows — that are copied onto every new board made from it (see **Scaffold Objects** below).

## Built-in Templates

Yando includes six built-in templates. Their zones are sized in sticky notes, so a new board opens at a readable zoom rather than as a huge, mostly empty canvas; zoom out as it fills.

### Business Model Canvas (BMC)
Nine zones covering: Key Partners, Key Activities, Key Resources, Value Propositions, Customer Relationships, Channels, Customer Segments, Cost Structure, and Revenue Streams. Each column holds three notes across.

### Lean Canvas
The startup version of the BMC: Problem, Solution, Unique Value Proposition, Unfair Advantage, Customer Segments, Key Metrics, Channels, Cost Structure and Revenue Streams.

### SWOT Analysis
Four quadrants of twelve notes each: Strengths, Weaknesses, Opportunities, and Threats.

### Impact/Effort Matrix
Four quadrants — Quick Wins, Big Bets, Fill-ins and Money Pits — for deciding what to work on.

### RICE Scoring
Four columns — Reach, Impact, Confidence and Effort — for scoring features.

### Matrix 2x2
A four-quadrant grid with axes for any two-axis comparison. Each note's position is exported as coordinates from −10 to +10 on both axes.

## Browsing Templates

Navigate to **Templates** from the top navigation. You'll see:

- **Built-in templates** - Pre-configured, available to everyone
- **Your templates** - Custom templates you've created
- **Shared by Others** - Templates other people on this Yando have shared (see **Sharing Templates** below)

Click any template card to see its detail page with a full-size canvas preview.

## Creating Custom Templates

1. Go to **Templates** and click **New Template**
2. Fill in the form:
   - **Name** (required)
   - **Description** (optional)
   - **Canvas Width/Height** - Dimensions in pixels
   - **Share with everyone on this Yando** - Lists the template under *Shared by Others* for everyone (see **Sharing Templates**)
3. Use the **Visual Zone Editor** to add zones

### Visual Zone Editor

The zone editor is a WYSIWYG canvas where you drag and resize zones — zones look exactly as they will on a board, with their colour, icon, title and prompt:

- Click **Add Zone** to create a new zone
- Drag zones to reposition them
- Drag zone edges to resize
- Set zone properties in the sidebar:
  - **Name** - Label shown on the canvas
  - **Shape** - Rectangle, circle, pie slice, or rectangular sector
  - **Description** - The zone's prompt, shown on boards — write it as the question the zone answers
  - **Category** - What the zone holds (Finance, Customer & people, …); sets its colour and icon and is included in exports. Hover a category to see what it's for
  - **Icon** - Optional [Lucide](https://lucide.dev/icons/) icon name to replace the category's icon
  - **Other Colour** - Pick a colour instead of a category; the zone becomes Neutral, so its colour carries no meaning in exports

### Zone Shapes

- **Rectangle** - Standard rectangular zones (most common)
- **Circle** - Circular zones, useful for hub-and-spoke layouts
- **Pie Slice** - Subdivide a circle into 2-6 wedge segments with precise angular boundaries
- **Rectangular Sector** - Angular wedges that fill a whole rectangle right to its edges (no empty corners), so every point belongs to exactly one zone. Ideal for stakeholder maps, priority wheels and compass-style diagrams — and for triangles: a square split by lines from its centre to its corners (like the Value Proposition Canvas's Value Map) is made of rectangular sectors

**Where new sticky notes go.** Notes added to a zone without a position (by an AI assistant, the API, or grid auto-positioning) fill rectangles in reading order, below the zone's header. In circles, pie slices and rectangular sectors they start in the open middle of the region and spread outward, staying clear of the dividing lines and of the zone's header.

### How Zones Look on a Board

Each zone is a soft, solid field with rounded corners, and pie slices and rectangular sectors are separated by clean gaps. Every zone has a header:

- **Icon badge** — a small icon in the zone's colour
- **Title** — the zone's name
- **Prompt** — the zone's description, shown as a guiding question under the title. Write descriptions as the question the zone answers (e.g. "How will this make money?")

When you zoom out, prompts hide once they'd be too small to read and titles grow so the board still works as a map. Zone colours follow the light or dark theme automatically.

### Zone Categories: Colour Means Something

Every zone has a **category** saying what kind of information belongs there. The category sets the zone's colour and icon, so "green = money" reads at a glance, and it's written into JSON and Markdown exports with its meaning — so when you hand an export to an AI, it knows which zones hold the financial picture, the risks, the next steps and so on, whatever the template.

| Category | Colour | Holds |
|----------|--------|-------|
| Finance | Green | Costs, revenue, pricing, budget |
| Customer & people | Blue | Segments, users, stakeholders, channels to them |
| Problem & risk | Rose | Problems, pains, weaknesses, threats, risks |
| Idea & opportunity | Amber | Ideas, opportunities, gains |
| Solution & product | Teal | Features, solutions, advantages |
| Value & goals | Violet | Value propositions, goals, outcomes |
| Action & next steps | Orange | Actions, owners, decisions to make |
| Metrics & evidence | Slate | Metrics, KPIs, evidence, data |
| Team & roles | Pink | Team, roles, partners, responsibilities |
| Timeline | Sand | Phases, milestones, deadlines, sequence |
| Neutral | Grey | Notes, parking lot, assessment |

Existing zones were given a category from their names (e.g. *Revenue Streams* → Finance, *Pains* → Problem & risk); zones whose names didn't clearly match are Neutral and keep their colour. Templates built by an AI assistant through the MCP server get categories and prompts automatically; in the zone editor, pick a zone's category in its properties panel.

### Sticky Note Colours

Sticky notes come in five colours, each with a meaning: **yellow** = idea, **green** = decision, **red** = concern, **blue** = action, **purple** = question. Hover a swatch in the colour picker to see its meaning. Notes coloured with older palette colours keep their meaning (an old yellow note is still an idea) and switch to the new shades automatically; notes in other colours (such as teal) keep their colour but carry no meaning.

Rectangles can be split into horizontal strips, vertical strips, or radial sectors: pick the direction and count, then click **Apply**.

### Other Colours

If a zone doesn't hold one kind of information, you can give it one of 10 **Other Colours** instead of a category (pastels in light mode, deeper shades in dark mode, switching automatically with the theme). Such zones count as Neutral in exports.

### Canvas Resize Tools

- **Fit to Zones** - One-click resize to fit all zones with padding
- **Edge Drag Handles** - 8 handles for direct canvas edge manipulation
- **Content Bounds Indicator** - Amber dashed rectangle showing zone bounding box

## Scaffold Objects

Scaffold objects are the fixed content a template puts on every new board: a title, section headers, instructions, an example sticky note, framing shapes, or lines and arrows connecting zones. They're copied onto the board when it's created — changing a template's scaffold later doesn't alter boards that already exist.

Scaffold can include:

- **Text** — titles and helper text, in bold or regular, aligned left, centre or right. Text set to the automatic colour stays readable in both light and dark mode
- **Sticky notes** — worked examples showing people what to add
- **Shapes** — rectangles, circles and triangles for frames and markers
- **Lines** — straight or multi-segment, in any direction, solid or dashed, with optional arrowheads. Use them for diagonal dividers, connectors and flows between zones

Objects can be rotated and made semi-transparent, and scaffold is often **locked** so it stays in place — people can still unlock it on their own board if they need to (see *Locked Objects* in [Real-Time Collaboration](/docs/collaboration/)).

Scaffold objects are currently added by AI assistants through the MCP server or via the API — see below.

## Building Templates with AI

Connected through the [MCP Server](/docs/mcp-server/), an AI assistant such as Claude can build a complete template from a plain-language description or a reference image: it lays out the zones, previews the result as an image to check it, creates the template, adds titles, lines and other scaffold, and can create a board from it for you to open. See **Building Templates with Claude** on the MCP Server page for example prompts and tips.

## Customizing Templates ("Use as Starting Point")

You can clone any accessible template to create your own version:

1. On a template's card or detail page, click **Customize**
2. The form is pre-populated with "Copy of [name]", description, and all zones
3. Modify the name, zones, or canvas dimensions as needed
4. Click **Save**

The cloned template is always owned by you and set to private.

## Sharing Templates

To share a template you made, open it, click **Edit**, and tick **Share with everyone on this Yando**. It gets a **Shared** badge and appears for everyone else under **Shared by Others** on the Templates page, where they can view it and see its preview. You can also ask an AI assistant connected through the MCP server to share or unshare it.

When someone clicks **Use Template** on a shared template, Yando gives them **their own copy** — named like "Value Proposition Canvas (from Alice)" — and opens board creation with the copy selected. Using it again reuses the same copy. Because everyone works from their own copy:

- Your later edits to the original never change anyone else's boards
- You can stop sharing or delete the original at any time without breaking boards made from it
- People can freely adapt their copy (Edit / Customize) without affecting yours

A template with layout errors (for example a zone that runs off the canvas) can't be shared until they're fixed.

## Editing a Template That's in Use

A template's zones and canvas size are the layout of every board built from it, so changing them changes all of those boards. The zone editor lists the boards and asks you to tick **Also change these boards** before it saves such a change (renaming the template or editing its description never needs it); an AI assistant is refused until you've agreed. Open boards redraw straight away.

Renaming, moving, resizing or recolouring a zone keeps that zone's identity, so sticky notes on those boards stay in the zone. Deleting a zone moves the notes that were in it to *unzoned* — nothing is deleted, but they'll no longer be grouped under that zone in exports.

## Changing One Board's Zones

To change the zones of just one board, open the board and click **Edit this board's zones** (the layout button in the board's header; also on the board's edit page, under *Board Template*). It's the template editor, showing the board's notes faded: move, resize, add or delete zones, then **Save Layout**. You can also ask your AI assistant — "add a Risks zone to this board".

The first such change gives the board its own copy of the layout: the template and your other boards are untouched. The board's notes follow their zones: move a zone and its notes move with it; resize it and they stay where they are, pulled back inside if they'd end up outside. Notes in a zone you delete stay where they are, outside any zone. Owners and editors of the board can do this, on every plan.

A board with its own layout says so on its edit page (**Edit board**, under *Board Template*): *This board has its own layout, based on …*. Later changes to the original template don't reach it. These copies don't appear in your template list; to reuse one, click **Save as template** there — it becomes an ordinary template you can build new boards from.

## Template Switching on Existing Boards

When editing a board, you can change its template:

1. Open the board edit form
2. Select a new template from the dropdown
3. Confirm the change

Objects are remapped using:

1. **Zone name matching** (case-insensitive) - Objects stay in zones with the same name
2. **Position-based fallback** - Remaining objects are assigned by their canvas position

A success message shows remapping statistics (e.g., "5 by name, 3 by position, 2 scaled").


---

# Real-Time Collaboration

## Sharing Boards

There are two ways to give someone access to a board:

### Share Link

1. Open the board and click the **Share** button
2. Choose a permission level (**View Only** or **Can Edit**)
3. Click **Generate Link** and send it to your collaborator
4. When they open the link, they are automatically added to the board

### Via Project Membership

If a board is part of a project, all project members automatically have access to it. Project owners and editors can edit the board; project viewers can view it. See [Projects](/docs/projects/) for how to add a board to a project and what happens to access when you do.

If someone has access through both a direct board share and a project, the **higher permission wins** — a direct editor role on the board is never downgraded by a viewer project membership.

The **Share** dialog also shows the board's project at the top, so you can see — and change — who has access through it.

### Roles

- **Viewer** - Can see the board but not edit
- **Editor** - Can add, edit, and delete objects

Members see shared boards under **Shared with Me** on their boards page.

## Real-Time Collaboration

When multiple users open the same board, they collaborate in real time:

### Live Cursors

Each user's cursor is visible to others, showing:

- A colored pointer matching the user's avatar color
- The user's display name floating near the cursor
- Smooth animated movement as they navigate

### Selection Locking

When a user selects an object, it becomes locked for others:

- A colored border appears around the locked object
- A floating label shows who has it selected
- Other users cannot move or edit the locked object
- Locks are released automatically when the user deselects

This prevents conflicting edits on the same object.

### Locked Objects

Separately from the temporary selection lock above, any object can be **locked** so it stays put — useful for titles, frames and divider lines that shouldn't be nudged by accident. Templates often include locked objects.

A locked object:

- Can be selected, but not moved, resized, rotated, edited or deleted
- Is left out when you drag-select several objects, so it can't be carried along
- Shows a notice if you double-click it

To lock or unlock an object, select it and click **Lock** / **Unlock** in the floating object toolbar. Owners and editors can do this; the change appears for everyone on the board immediately.

### Multi-Tab Support

You can open the same board in multiple browser tabs. Each tab has its own channel identity, so:

- Your cursor appears correctly in each tab
- You won't see your own locks from another tab
- Each tab operates independently

## Saving and Connection

Every change is saved automatically. The indicator next to the board title shows where things stand:

- **Saved** — everything is on the server
- **Saving...** — a change is on its way
- **N unsaved changes** — changes couldn't be saved yet; Yando keeps them and retries automatically
- **Offline · N unsaved** — your device has no connection; changes are kept and saved as soon as it's back

If the live connection drops, a banner shows that Yando is reconnecting, and your changes keep being saved another way in the meantime. If you try to close the tab while changes are still unsaved, your browser asks you to confirm.

## Active Users

The board toolbar shows how many users are currently viewing the board. Presence indicators update in real time as users join and leave.

## Board History (Snapshots)

Yando takes daily snapshots of each board's state:

- **Automatic**: Snapshots are created daily (if the board has changed)
- **Change Summary**: Each snapshot includes counts of added, edited, and deleted objects
- **Read-Only**: View historical snapshots from the board detail page
- **Retention**: Snapshots are kept for 90 days by default

### Viewing Board History

1. From the board list, click on a board to see its detail page
2. Look for the **History** section
3. Click a snapshot to see the board's state at that point in time

Snapshots are read-only - you can see what the board looked like but cannot modify the snapshot.


---

# Export & Import

## Export Formats

Yando supports four export formats, accessible from the toolbar on any board:

### PNG (Image)

Exports the board as a PNG image. Smart cropping ensures the image is tightly fitted:

- **Template boards**: Cropped to zone boundaries with padding
- **Non-template boards**: Cropped to the object bounding box with padding
- Hidden sticky notes are excluded from the export

### PDF (Document)

Exports the board as a multi-page PDF document containing:

- A cropped image of the board canvas
- A text summary of all objects organized by zone
- Hidden sticky notes are excluded

### Markdown

Exports board content as a structured markdown file:

- A **legend** at the top: what each zone category on the board means, and what each sticky-note colour means
- Objects grouped by zone, in the template's order — every zone is listed, including empty ones
- Zone headings include the category (e.g. *Revenue Streams · Finance*), followed by the zone's prompt
- Sticky notes are labelled with their meaning (e.g. *[Sticky Note · decision]*)
- Hidden sticky notes are excluded
- Useful for feeding board content to AI tools: the export says what every zone and colour means, not just what things are called

### JSON (Data)

Exports the complete board data as a JSON file:

- Board metadata (title, description, template, canvas dimensions)
- A `legend`: `zone_categories` (the categories used on the board and what they mean) and `note_colors` (what each sticky-note colour means)
- Every zone with its `category`, `category_label`, `category_meaning` and `prompt` (the zone's description), plus its objects
- All objects with full properties (position, size, rotation, data); sticky notes also carry `color_meaning` (idea, decision, concern, action, question — or `null` for other colours)
- Can be re-imported to create a new board

## Import from JSON

### Creating a New Board from JSON

1. Go to **Boards** and click **New Board**
2. Upload a JSON file in the import section
3. Preview shows the title, template, and object count
4. Optionally change the title, description, or template
5. Click **Create Board**

The import process:

- Generates fresh UUIDs for the board and all objects (security measure)
- Sets the current user as the owner
- Matches zones by name (exact, then ignoring case); if a zone's name doesn't match, its `category` is used when the template has exactly one zone of that category
- Validates the JSON schema, object types, and required fields (each object needs only `type` and `data`)
- Places sticky notes for you: a note keeps its position when it lies inside its zone (so exports come back exactly as they were); a note without a position, with one outside its zone, or on top of another imported note goes in the next free spot in its zone. Notes outside zones go below the board's content when they have no position or would land on another note. The import tells you how many notes it placed, and which zone names in the file the board's template doesn't have (their notes are added outside the zones)
- Uses atomic transactions (all-or-nothing)
- Lays text boxes placed in a zone out inside that zone, below its name and prompt. If a zone has more text than fits even at the smallest size, the text is kept in full but shown cut off at the bottom of the zone with a **+N lines** marker — click it to read the rest — and the import tells you which zones overflowed. Exports always contain the full text

### Importing to an Existing Board

You can add objects from a JSON file to an existing board:

1. Open the board canvas
2. Click the **Import** button in the toolbar
3. Select a JSON file
4. Objects are added without modifying existing content

This is useful for the LLM workflow:

1. Export your board to JSON
2. Feed the JSON to an LLM for analysis or enhancement
3. Import the LLM's output back to the same board

### JSON Schema

The expected JSON structure:

```json
{
  "board": {
    "title": "My Board",
    "description": "Optional description",
    "template": "Business Model Canvas",
    "canvas_width": 3200,
    "canvas_height": 1800
  },
  "zones": {
    "Revenue Streams": {
      "zone": {
        "name": "Revenue Streams",
        "category": "finance",
        "prompt": "How will this make money?"
      },
      "objects": [
        {
          "type": "sticky_note",
          "x": 100,
          "y": 200,
          "width": 200,
          "height": 150,
          "data": {
            "text": "Note content",
            "color": "#FFE584"
          }
        }
      ]
    }
  },
  "unzoned_objects": []
}
```

The `zone` block is optional on import (only `objects` is needed); exports also include the category label and meaning, and a `legend`.

Object types: `sticky_note`, `text_box`, `shape`

For shapes, the `data` object includes a `shapeType` field: `rectangle`, `circle`, `triangle`, or `line`.

## Export Visibility

Hidden sticky notes (those toggled to hidden on the canvas) are excluded from **all** export formats:

- PNG: Not rendered in the image
- PDF: Not in the image or the text summary
- Markdown: Not included in the text output
- JSON: Hidden notes are still included in JSON exports (they carry a hidden flag)


---

# Projects

## What are Projects?

Projects are containers that group related boards and markdown pages together. They provide a workspace for organizing work around a theme, product, or initiative.

## Creating a Project

1. Navigate to **Projects** from the top navigation
2. Click **New Project**
3. Fill in:
   - **Title** (required)
   - **Description** (optional)
   - **Color** - A color used for visual identification
4. Click **Create**

## Adding Boards to a Project

Boards in a project appear in the project sidebar alongside pages. You can add a **new** board or one you've **already been working on**, from whichever screen you're on.

### Create a new board in a project

- In the project sidebar, click **+ Add → New Board**, or
- When creating a board from the Boards page, choose the project in the **Project** field

### Add a board you already have

**From inside the project** — in the project sidebar, click **+ Add → Existing Board…**. Search your boards, tick one or more, and click **Add**. In the list:

- Boards that are already in another project show **Move from *Project name*** — adding them moves them here
- Boards you can edit but don't own are greyed out (*Owned by … — ask them to add it*); only a board's owner can put it in a project

**From the board itself** — open the board, click **Share**, and use the **Project** section at the top:

- *Not in a project* → **Add to project…**, then pick a project
- **+ New project from this board** creates a project with this board as its first item
- If the board is already in a project, use **Move…** or **Remove**

**From the Boards page** — hover a board card you own and click **+ Project**.

Standalone boards you own also show a small **Organize into a project?** hint in the bottom-left corner of the board; click it to open the Share dialog, or × to dismiss it for good.

Newly added boards go to the **top** of the project sidebar, and the sidebar updates straight away — no page reload. Every add, move and remove shows a notification with an **Undo** button.

### Who gets access

Adding a board to a project gives **every project member** access to it, and moving a board out of a project removes access for that project's members. Before anything changes, Yando shows exactly who will gain and who will lose access, for example:

> 3 people will get access — Bob (editor), Carol (viewer), Dave (viewer)

If nobody's access changes, the board is added straight away.

People you'd shared the board with directly keep their access either way. If they aren't in the project, you're offered a checkbox to **invite them to the project too** (unchecked by default, with their current board role suggested).

### Removing a board from a project

Only the board's owner or the project's owner can remove a board from a project. Removing it never deletes the board — it becomes a standalone board again.

## Markdown Pages

Projects can contain markdown pages for notes, documentation, or planning:

### Creating a Page

1. Open the project
2. Click **Add Page** in the sidebar
3. Enter a title and start writing in the markdown editor

### Editing Pages

The page editor uses EasyMDE (a markdown editor) with:

- Toolbar for formatting (bold, italic, headings, lists, links, code)
- Live preview mode (click the eye icon)
- Auto-save every 2 seconds
- Manual save with **Ctrl+S**

### Reader View

Click **Read** to switch from the editor to a rendered reader view. Click **Edit** to return.

### Importing Markdown Files

You can import `.md` files as project pages:

1. Click **Import Pages** on the project detail page
2. Drag and drop or select one or more `.md` files
3. Each file becomes a separate page
4. Title is extracted from the first heading (or filename if no heading)

## Sidebar Ordering

The project sidebar shows all boards and pages. To reorder:

1. Drag and drop items in the sidebar to change their order
2. The order is saved automatically

Only project owners and editors can reorder items.

## Sharing & Member Management

### Inviting Members via Share Link

Project owners can invite members by generating a share link:

1. Open the project management page
2. In the **Members** section, choose a permission level: **View Only** or **Can Edit**
3. Click **Generate Link**
4. Copy the link and share it with your collaborators

When someone opens the link (they must be logged in), they are automatically added to the project.

### Managing Active Links

- Active share links are listed below the generate button, showing permission level and usage count
- Click **Copy** to copy a link to your clipboard
- Click **Revoke** to deactivate a link — anyone who hasn't used it yet will see an error page

### Member Roles

- **Editors** can create boards, add/edit pages, and reorder the sidebar
- **Viewers** can see boards and pages but not modify them

Project owners can change a member's role or remove them from the member list.

### How Permissions Work Together

Project members automatically get access to **all boards** within the project — in the browser, through the API, and through AI assistants connected via the MCP server:

| Project role | Access to the project's boards |
|---|---|
| Owner | Editor |
| Editor | Editor |
| Viewer | Viewer |

If someone has access to a board through both a direct board share and the project, **the higher role wins** — a viewer on the board who is an editor in the project can edit, and vice versa.

**Share links only upgrade, never downgrade.** If an existing editor clicks a viewer invite link, their role stays as editor. If a viewer clicks an editor link, they are upgraded to editor.

### Member Limits

Free accounts can have up to 3 members per project. Upgrade to Pro for up to 20.


---

# API Reference

## Authentication

All API endpoints require session authentication. You must be logged in via the web interface, or send the session cookie with your requests.

For programmatic access, authenticate first:

```bash
# Login and save cookies
curl -c cookies.txt -X POST https://your-yando-instance/accounts/login/ \
  -d "login=user@example.com&password=yourpassword" \
  -H "Referer: https://your-yando-instance/"
```

Then include `-b cookies.txt` in subsequent requests.

## Rate Limiting

API endpoints are rate-limited per user. If you exceed the rate limit, you'll receive a `429 Too Many Requests` response.

| Scope | Limit |
|-------|-------|
| General API requests | 100 / hour |
| Board create | 30 / hour |
| Board delete | 10 / hour |
| Board import | 20 / hour |
| Project create | 20 / hour |
| Project delete | 10 / hour |

The specific limits are separate allowances — creating a board does not use up your general 100/hour.

**Keeping well under the limit.** Adding objects counts against the general allowance, so creating them one request at a time is what usually exhausts it. Use the bulk object creation endpoint below (`POST /api/boards/{board_id}/objects/bulk/`) to add many objects in a single request, and target zones by **name** rather than fetching the board to look up a zone ID. Together these take a typical "create a board and fill it with 16 notes" workflow from around 34 requests down to 3.

Limits reset on a rolling one-hour window. If your account has a legitimate need for higher throughput — a demo environment or an internal integration — an administrator can exempt it from rate limits.

---

## POST /api/boards/import/

Create a new board from exported JSON data.

### Request

Accepts two content types:

**JSON body** (`application/json`):

```bash
curl -b cookies.txt -X POST https://your-yando-instance/api/boards/import/ \
  -H "Content-Type: application/json" \
  -H "X-CSRFToken: <token>" \
  -d @board-export.json
```

**File upload** (`multipart/form-data`):

```bash
curl -b cookies.txt -X POST https://your-yando-instance/api/boards/import/ \
  -H "X-CSRFToken: <token>" \
  -F "json_file=@board-export.json"
```

### Query Parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `template` | string | Template name or UUID to override the JSON template |
| `title` | string | Override the board title from the JSON |
| `description` | string | Override the board description |

### Response (201 Created)

```json
{
  "id": "a1b2c3d4-...",
  "title": "My Board",
  "description": "Board description",
  "template": "Business Model Canvas",
  "object_count": 15,
  "url": "/boards/a1b2c3d4-.../"
}
```

### Errors

| Status | Description |
|--------|-------------|
| 400 | Invalid JSON, validation error, or missing required fields |
| 403 | Authentication required |

---

## POST /api/boards/{board_id}/objects/bulk/

Create many objects on a board in a single request.

Use this instead of calling `POST /api/boards/{board_id}/objects/` in a loop. Each request counts against your rate limit, so filling a 16-note board costs 1 request this way instead of 16.

### Request

```bash
curl -b cookies.txt -X POST \
  https://your-yando-instance/api/boards/{board_id}/objects/bulk/ \
  -H "Content-Type: application/json" \
  -d '{
    "objects": [
      {
        "object_type": "sticky_note",
        "zone": "Strengths",
        "data": {"text": "Strong brand recognition", "color": "#7BC950"}
      },
      {
        "object_type": "sticky_note",
        "zone": "Weaknesses",
        "data": {"text": "Thin margins", "color": "#FF6B6B"}
      }
    ]
  }'
```

### Object Fields

| Field | Required | Description |
|-------|----------|-------------|
| `object_type` | Yes | `sticky_note`, `text_box`, `shape`, `line`, or `image` |
| `data` | Yes | Type-specific properties — `text` and `color` for a sticky note |
| `zone` | No | Zone **name** (case-insensitive) or UUID on the board's template |
| `zone_id` | No | Zone UUID. Takes precedence over `zone` |
| `x`, `y` | No | Position. Derived from the zone when omitted |
| `width`, `height` | No | Size. Defaults to 200×150 for sticky notes, 300×100 for text boxes |
| `rotation` | No | Degrees (default 0) |
| `opacity` | No | 0.0–1.0 (default 1.0) |

**Targeting zones by name.** Passing `zone: "Strengths"` saves you fetching the board first to find its UUID. An unknown name returns a 400 listing the zones that do exist.

**Automatic placement.** When you give a zone and omit `x`/`y`, the server positions each object inside that zone, spacing successive objects so they don't overlap. Supply explicit coordinates to override this.

**Limits.** Between 1 and 200 objects per request. Send larger imports in chunks.

### Response (201 Created)

```json
{
  "count": 2,
  "created": [
    {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "object_type": "sticky_note",
      "x": 40.0,
      "y": 30.0,
      "width": 200.0,
      "height": 150.0,
      "data": {"text": "Strong brand recognition", "color": "#7BC950"},
      "zone_name": "Strengths",
      "version": 1
    }
  ]
}
```

Objects are returned in the order you sent them. Collaborators with the board open see them appear live.

### Errors

The request is **atomic** — if any object is invalid, none are created:

| Status | Description |
|--------|-------------|
| 400 | Empty list, more than 200 objects, unknown zone name, or an invalid entry |
| 403 | You do not have editor access to this board |
| 404 | Board not found |

Validation errors name the offending entry, for example:

```json
{"error": "Object at index 1: Zone 'Sxrengths' does not exist on this board's template. Available zones: Strengths, Weaknesses, Opportunities, Threats"}
```

---

## POST /api/boards/{board_id}/resize/

Resize a board's canvas dimensions.

### Request

```bash
curl -b cookies.txt -X POST \
  https://your-yando-instance/api/boards/{board_id}/resize/ \
  -H "Content-Type: application/json" \
  -H "X-CSRFToken: <token>" \
  -d '{"width": 4000, "height": 2400}'
```

### Response (200 OK)

```json
{
  "id": "a1b2c3d4-...",
  "canvas_width": 4000,
  "canvas_height": 2400
}
```

---

## PATCH /api/boards/{board_id}/update/

Update a board's title or description, or add it to, move it between, or remove it from a project.

```bash
curl -b cookies.txt -X PATCH \
  https://your-yando-instance/api/boards/{board_id}/update/ \
  -H "Content-Type: application/json" \
  -H "X-CSRFToken: <token>" \
  -d '{"project_id": "7f090fb7-..."}'
```

| Field | Description |
|-------|-------------|
| `title`, `description` | Owner or editor |
| `project_id` | Project UUID to add/move the board to, or `null` to remove it. Board owner only; you must be an owner or editor of the target project |

When `project_id` is sent, the response includes how access changed:

```json
{
  "id": "a1b2c3d4-...",
  "title": "Roadmap",
  "project": {"id": "7f090fb7-...", "title": "Q3 Planning", "color": "#E3F2FD"},
  "access_changes": {"gained_access": 2, "lost_access": 0}
}
```

---

## Templates

| Method | Endpoint | Description |
|--------|----------|-------------|
| GET | `/api/templates/` | Built-in, your own, and other users' shared templates. Each has a `scope` (`built_in`, `mine`, `public`) and `owner` |
| GET | `/api/templates/{id}/` | Zones and scaffold objects |
| POST | `/api/templates/create/` | Create a custom template (Pro) |
| PATCH | `/api/templates/{id}/update/` | Update metadata, zones, or sharing (`is_public`) — your templates only |
| POST | `/api/templates/{id}/clone/` | Copy a built-in, own, or shared template (the copy records `cloned_from`) |
| GET / POST | `/api/templates/{id}/objects/` | List or add scaffold objects |
| PATCH / DELETE | `/api/templates/{id}/objects/{object_id}/` | Change (partial) or remove a scaffold object |

Boards can be created from any template you can see (`template` accepts a name or UUID). Names match your own templates first, then built-ins, then shared ones. A template shared by someone else is used through **your own copy** — made on first use, reused afterwards — so the owner's later changes never affect your boards.

**Sharing.** `{"is_public": true}` shares a template with everyone on the instance; `false` stops sharing (existing copies are unaffected). Sharing is refused with a 400 while the layout has errors (e.g. a zone off the canvas).

### Zones

Each zone needs `name`, `x`, `y`, `width`, `height` (minimum 50×50, inside the canvas). Optional: `description` (the zone's prompt — write it as the question the zone answers), `category` (one of `finance`, `customer`, `problem`, `idea`, `solution`, `value`, `action`, `metrics`, `team`, `timeline`, `neutral`; sets the zone's colour and is exported with its meaning), `icon` (a Lucide icon name overriding the category's icon), `zone_shape` (`rectangle`, `circle`, `pie-slice`, `rect-sector`), `start_angle` / `end_angle` (required for pie-slice and rect-sector; degrees, 0 = east, clockwise, −90 = top), `background_color` / `border_color` (`#RRGGBB`; a zone with a category gets that category's colour unless you set one, and a colour sent without a category makes an "Other colour" zone that exports as neutral), `border_width`, `order`, `enable_grid_positioning`, `grid_columns`, `grid_padding`.

**Updating zones.** `zones` in an update is the complete list the template should have. Each entry is matched to an existing zone by `id`, then by unique case-insensitive name, and updated in place — boards built from the template keep their objects in that zone. Unmatched entries are created; existing zones missing from the list are deleted. Optional fields you leave out keep their current values. The response reports what happened:

```json
"zone_changes": {
  "updated": ["Strengths", "Weaknesses"],
  "created": ["Opportunities"],
  "deleted": ["Threats"],
  "unzoned_board_objects": 4
}
```

To shrink the canvas, send the adjusted zones in the same request — otherwise a resize that would leave zones off-canvas is rejected.

**Templates in use need confirmation.** A template's zones and canvas are the layout of every board built from it. While boards use the template, a request that changes `zones`, `canvas_width` or `canvas_height` is refused with **409** and `"code": "TEMPLATE_HAS_BOARDS"`, listing the `boards` (`id`, `title`, `owner`); repeat it with `"apply_to_boards": true` once the user has agreed. Metadata (`name`, `description`) never needs it. To change one board only, use the board's layout (below).

Boards follow a confirmed change: each board's canvas grows to hold the template's canvas and zones (it never shrinks), and boards open at the time redraw the new zones straight away.

### One board's zones: `/api/boards/{board_id}/layout/`

`GET` returns the board's zones and canvas: `{board_id, canvas_width, canvas_height, template: {id, name, own_layout, based_on}, zones}`. `own_layout: true` means the board has its own copy of the layout.

`PATCH` with `{"zones": [...], "canvas_width"?, "canvas_height"?}` (zones as for template updates — the complete list, matched by `id` or unique name) changes **only this board**: the first change gives it its own copy of its template (zone ids you read before still work), so the template and its other boards are untouched. Without a canvas size the canvas grows to hold the zones. The board's objects follow their zones: a moved zone takes them along; a resized one keeps them in place, pulled back inside if they'd fall outside. Owners and editors of the board. The response adds `own_layout_created`, `zone_changes` and `objects_moved`.

`POST /api/boards/{board_id}/layout/save-as-template/` with `{"name"?}` (board owner) turns the board's own layout into an ordinary template. Own layouts are left out of template lists, can't be used for new boards and can't be shared until saved as a template.

### Scaffold Objects

Scaffold objects are copied onto every new board created from the template. Send one object, or several at once (all-or-nothing, up to 100):

```bash
curl -b cookies.txt -X POST \
  https://your-yando-instance/api/templates/{id}/objects/ \
  -H "Content-Type: application/json" \
  -H "X-CSRFToken: <token>" \
  -d '{"objects": [
        {"object_type": "text_box", "x": 200, "y": 80, "width": 5600, "height": 180, "locked": true,
         "data": {"text": "Value Proposition Canvas", "fontSize": 120, "fontWeight": "bold", "textAlign": "center"}},
        {"object_type": "line", "x": 400, "y": 700, "width": 2400, "height": 2400, "locked": true,
         "data": {"points": [[0, 0], [2400, 2400]], "stroke": "#90A4AE", "strokeWidth": 8, "arrowEnd": true}}
      ]}'
```

Common fields: `object_type`, `x`, `y`, `width`, `height`, `data`, and optionally `rotation` (degrees clockwise about the top-left corner), `opacity` (0–1), `locked`, `z_index`, `zone_id`. A `PATCH` changes only the fields sent; `data` is merged key by key. Only object types that boards can display are accepted — see **Object Types** below.

---

## GET /api/boards/{board_id}/snapshots/

List all snapshots for a board, ordered by creation date (newest first).

### Request

```bash
curl -b cookies.txt \
  https://your-yando-instance/api/boards/{board_id}/snapshots/
```

### Response (200 OK)

```json
[
  {
    "id": "s1n2a3p4-...",
    "created_at": "2026-02-21T08:00:00Z",
    "object_count": 24,
    "board_version": 15,
    "change_summary": {
      "added": {"sticky_note": 2},
      "edited": {"text_box": 1},
      "deleted": {}
    }
  }
]
```

---

## GET /api/boards/{board_id}/snapshots/{snapshot_id}/

Retrieve a single snapshot's full data.

### Request

```bash
curl -b cookies.txt \
  https://your-yando-instance/api/boards/{board_id}/snapshots/{snapshot_id}/
```

### Response (200 OK)

Returns the full snapshot including `snapshot_data` containing the complete board state at that point in time.

---

## POST /api/projects/{project_id}/pages/import/

Import markdown files as project pages.

### Request

Upload one or more `.md` or `.markdown` files:

```bash
curl -b cookies.txt -X POST \
  https://your-yando-instance/api/projects/{project_id}/pages/import/ \
  -H "X-CSRFToken: <token>" \
  -F "files=@notes.md" \
  -F "files=@planning.md"
```

### Response (201 Created)

```json
{
  "pages_created": 2,
  "pages": [
    {
      "id": "p1a2g3e4-...",
      "title": "Notes",
      "url": "/projects/.../pages/p1a2g3e4-.../"
    }
  ],
  "errors": []
}
```

### Status Codes

| Status | Description |
|--------|-------------|
| 201 | All files imported successfully |
| 207 | Partial success - some files imported, some had errors |
| 400 | No files provided or all files failed |
| 403 | Not an owner or editor of the project |
| 404 | Project not found |

---

## JSON Export Schema Reference

When exporting a board to JSON, the structure is:

```json
{
  "board": {
    "title": "Board Title",
    "description": "Optional description",
    "template": "Template Name or null",
    "canvas_width": 3200,
    "canvas_height": 1800
  },
  "zones": {
    "Zone Name": [
      {
        "type": "sticky_note",
        "x": 100,
        "y": 200,
        "width": 200,
        "height": 150,
        "rotation": 0,
        "data": {
          "text": "Content here",
          "color": "#FFEB3B"
        }
      }
    ]
  },
  "unzoned_objects": [
    {
      "type": "text_box",
      "x": 500,
      "y": 100,
      "width": 300,
      "height": 50,
      "data": {
        "text": "Unzoned text"
      }
    }
  ]
}
```

### Object Types

| Type | Data Fields |
|------|-------------|
| `sticky_note` | `text`, `color` |
| `text_box` | `text`, `fontSize`, `fontFamily`, `fontWeight` (`normal`, `bold`), `textAlign` (`left`, `center`, `right`), `color` (`#RRGGBB` or `auto` to follow the theme) |
| `shape` | `shapeType` (`rectangle`, `circle`, `triangle`, `line` — a horizontal bar), `fill`, `stroke`, `strokeWidth` |
| `line` | `points` (2–200 `[x, y]` pairs relative to the object's `x`/`y`), `stroke`, `strokeWidth`, `dashed`, `arrowStart`, `arrowEnd` |

All objects also carry `rotation`, `opacity` and `locked`.


---

# MCP Server (AI Integration)

## What is the MCP Server?

The MCP (Model Context Protocol) server lets AI assistants like Claude interact with your Yando boards. You can ask Claude to create boards, add sticky notes, export content, manage projects, and more — all through natural conversation.

For example, you can say "Create a SWOT Analysis board for our product launch" and Claude will create the board with the right template, or "Add a red sticky note about the budget risk" and it will appear on your board in real time.

## Prerequisites

1. A Yando account
2. An API key (see below)
3. An MCP-compatible AI client (Claude Desktop, Claude.ai, or Cursor)

## Step 1: Create an API Key

1. Click your avatar in the top-right corner and go to **Settings**
2. Scroll down to the **API Keys** section
3. Click **Create API Key**
4. Give it a descriptive name (e.g., "Claude Desktop")
5. Copy the key immediately — it is only shown once

Your API key starts with `ynd_` and looks like `ynd_abc123def456...`. Keep it secret — anyone with this key can access your boards.

## Step 2: Connect Your AI Client

Choose the setup that matches your client:

### Claude.ai

Claude.ai connects to the Yando MCP server over the internet using OAuth.

1. Go to **Settings → MCP Servers → Add custom**
2. Name: `Yando`
3. URL: `https://mcp.bigdeez.com/mcp`
4. Leave the OAuth fields blank — Claude.ai discovers them automatically
5. You'll be redirected to a consent page — enter your Yando API key to approve access

### Claude Desktop

Claude Desktop connects to the remote MCP server using your API key directly.

1. Open Claude Desktop settings (gear icon → Developer → Edit Config)
2. Add this to your configuration:

```json
{
  "mcpServers": {
    "yando": {
      "url": "https://mcp.bigdeez.com/mcp",
      "headers": {
        "Authorization": "Bearer ynd_your_key_here"
      }
    }
  }
}
```

Replace `ynd_your_key_here` with your API key.

3. Restart Claude Desktop

### Cursor

Cursor uses the same configuration as Claude Desktop:

```json
{
  "mcpServers": {
    "yando": {
      "url": "https://mcp.bigdeez.com/mcp",
      "headers": {
        "Authorization": "Bearer ynd_your_key_here"
      }
    }
  }
}
```

## What Can Claude Do?

Once connected, Claude has access to 47 tools organized into these categories:

### Board Management

- **List your boards** — See all boards you own or have access to, including boards shared with you through a project
- **Create boards** — Create blank boards or use a template (e.g., Business Model Canvas, SWOT Analysis)
- **Update boards** — Change the title or description, or add, move or remove the board from a project (Claude reports how many people gained or lost access)
- **Delete boards** — Remove boards you own

### Working with Objects

- **Add many sticky notes at once** — Fill a whole board in a single step
- **Add a sticky note** — Place a single color-coded note, optionally targeting a zone by name
- **Add text boxes** — Add text boxes for longer content; written into a zone, the text fills it (see below)
- **Tidy zones** — Re-fit the text in some or all zones, e.g. on boards made before zone headers
- **Update objects** — Change text, position, or other properties
- **Delete objects** — Remove objects from a board
- **List objects** — See everything on a board

**Zone-aware placement.** When Claude adds notes to a zone, Yando works out where to put them — you can say "add five ideas to the Strengths zone" and they'll be laid out neatly inside it without overlapping. Claude never needs to know the exact coordinates, or even look up the zone first; the zone's name is enough.

**Writing into a zone.** Ask Claude to "summarise the Problem notes into the Problem zone" and the text fills the zone below its header — the zone's name and prompt stay visible — across its full width, at the largest size that fits. More text in the same zone shares the space at one size. Your sticky notes stay on top of the text; press **H** to hide them and read it. Text you place yourself stays exactly where you put it. To re-fit text on an older board, ask Claude to "tidy the zones" (it re-fits every text box in the zones you name).

**Zone text never spills into other zones.** Claude can see how much room each zone has left, and text that wouldn't fit even at the smallest size is turned down, so Claude writes a tighter summary, moves separate points into sticky notes, or puts long-form writing in a project page instead. Text that arrives some other way — a JSON import, or your own edits — is kept in full but shown cut off at the bottom of the zone with a **+N lines** marker: click the text to read all of it, and exports always include the full text. Editing zone text re-fits the zone when you finish; deleting it closes the gap; dragging it somewhere else makes it ordinary text that stays where you put it.

**Filling a board is one step, not dozens.** Asking Claude to "fill this SWOT board out" sends all the notes together in a single request rather than one per note. A 16-note board takes one step instead of 32. Beyond being much faster, this is what keeps a board-filling session comfortably within the API rate limit (see **Rate Limits** below).

### Sticky Note Colors

Sticky note colors carry meaning. When asking Claude to add notes, you can specify a color:

| Color | Meaning |
|-------|---------|
| Yellow | Ideas and suggestions |
| Green | Decisions and agreements |
| Red | Concerns and blockers |
| Blue | Action items and tasks |
| Purple | Questions and follow-ups |
| Orange | General notes (no meaning in exports) |

### Templates

- **Browse templates** — See built-in templates, your own, and templates shared by others (with who shared them). Creating a board from a shared template automatically uses your own copy
- **Get template details** — View zones, scaffold objects and layout information
- **Create custom templates** — Describe a framework in plain language and Claude will build the template (zones with categories and prompts, shapes)
- **Update templates** — Rename, resize, or edit zones on templates you own. Boards already built from the template keep their notes in the edited zones
- **Clone templates** — Copy a built-in, your own, or a shared template as a starting point
- **Share templates** — Share a template with everyone on this Yando, or stop sharing it (others always use their own copy)
- **Add / update / remove zones** — Modify individual zones without rewriting the whole template
- **Add, update and delete scaffold objects** — Titles, helper text, example notes, shapes, and lines or arrows that appear on every new board from the template; many can be added in one step
- **Validate a draft layout** — Catch overlapping zones, angle wrap-around bugs, coverage gaps, and sizing issues before saving
- **Render a template preview** — Get an image of a draft or saved template — zones and scaffold, drawn the way boards draw them — so Claude can check the layout before you see it

### Template Layout Helpers

These tools compute zone coordinates for common patterns so Claude doesn't have to do the arithmetic:

- **Grid zones** — Even rows × columns with padding
- **Strip zones** — Horizontal or vertical bands
- **Pie zones** — Evenly divided circular wedges
- **Rect-sector zones** — Angular wedges that fill a rectangle (full coverage, no dead corners)
- **Matrix zones** — 2×2 matrices (e.g., Impact/Effort, Eisenhower)

### Export & Import

- **Export to JSON** — Get a structured export of a board's content, including what each zone and note colour means
- **Export to Markdown** — Get a readable text version of a board, with a legend of zone categories and note colours
- **Meeting transcripts to boards** — Paste a transcript (or attach a .vtt / .srt / .txt export) and Claude pulls out the decisions, actions, ideas, concerns and questions as colour-coded sticky notes in the right zones. Claude does the reading; you can also pick the **meeting_transcript_to_board** prompt from the Yando connector

### Board History

- **List snapshots** — See daily snapshots of a board's history
- **View a snapshot** — See the board's full state at a point in time

### Projects & Pages

- **Manage projects** — Create, update, list, and delete projects
- **Manage pages** — Create, update, list, and delete markdown pages within projects

## Building Templates with Claude

You can describe a framework — or share a picture of one — and Claude will turn it into a reusable Yando template. Behind the scenes it:

1. Checks whether an existing template is a close match and, if so, copies and adapts it
2. Lays out the zones using the layout helpers (grids, strips, pies, sectors, 2×2 matrices) — sized by how many sticky notes each zone should hold (four across by three down unless you say otherwise), with the canvas fitted around them — and gives each zone a **category** (what kind of information it holds — it sets the zone's colour) and a **prompt** (the question the zone answers)
3. Validates the layout and renders a preview image to check it before saving
4. Creates the template, then adds titles, section headers, helper text, and lines or arrows in one step
5. Previews the finished template and offers to create a board from it so you can open it

**Good prompts are specific about structure:**

> "Create a Value Proposition Canvas template: on the left, a square split into Products & Services, Gain Creators and Pain Relievers; on the right, a circle split into Gains, Customer Jobs and Pains. Add a bold title and lock it."

> "Make a customer journey template with five stages as columns — Awareness, Consideration, Purchase, Retention, Advocacy — and a dashed arrow running left to right across the top."

> "Here's a photo of the framework from our workshop — recreate it as a template."

> "Share my Value Proposition Canvas template with the team."

**What templates can contain today:**

- Zones shaped as rectangles, circles, pie slices or rectangular sectors
- Text (bold or regular; left, centre or right aligned), sticky notes, rectangles, circles, triangles
- Lines in any direction with optional dashes and arrowheads
- Rotation, transparency, and locked objects that stay in place on new boards

Any rectangle split by lines from its centre to its corners or sides is reproduced **exactly** — for example a square cut by its diagonals into triangles, or the Value Proposition Canvas's Value Map (a triangle on the left, top and bottom regions on the right). Shapes that don't radiate from a centre, such as funnels or trapezoids, are approximated, and Claude can draw the true outline with lines on top. Claude will tell you what it approximated.

**Refining a template** is conversational: "make the title bigger", "rename Pains to Frustrations", "add a helper note in each zone". Editing zones on a template that's already in use keeps existing boards' notes in place; removing a zone moves those notes to *unzoned*, so Claude will check with you first.

## Example Conversations

Here are some things you can ask Claude once the MCP server is connected:

**Creating a board:**
> "Create a new SWOT Analysis board called 'Q3 Product Review'"

**Adding ideas to a specific zone:**
> "Add these as yellow sticky notes to the Strengths zone: faster onboarding, better docs, improved search"

**Filling out a whole board at once:**
> "Fill out this SWOT board for a mid-size UK coffee roastery — four or five points in each quadrant, green for strengths, red for threats"

**Flagging concerns:**
> "Add a red sticky note about the timeline risk for the API migration"

**Building a custom template:**
> "Create a custom template for a RACI chart — four vertical columns for Responsible, Accountable, Consulted, Informed"

**Previewing a template:**
> "Show me what my new RACI template looks like before I use it"

**Exporting content:**
> "Export my 'Sprint Planning' board as Markdown"

**Working with projects:**
> "Create a project called 'Product Launch' and add a page with our launch checklist"

**Reviewing history:**
> "Show me the snapshots for the Q2 Review board — what changed last week?"

**Meeting notes:**
> "Here's the transcript of today's planning meeting — put the decisions, actions and open questions on my Sprint Review board"

## Rate Limits

To keep the service responsive for everyone, API access is limited to **100 requests per hour** per account, with separate allowances for creating and deleting boards.

In normal use you will not notice this. Claude batches its work — filling a board sends every note in one request rather than one per note — so a typical "create a board and fill it in" conversation uses around three requests, and you could run dozens of those in an hour.

**If you do hit the limit,** Claude will report an error mentioning rate limiting or a "429" response. The limit resets on a rolling one-hour window, so waiting a few minutes and continuing is usually enough.

**Running demos or a heavy internal integration?** Administrators can lift the rate limit entirely for a specific account. If you regularly hit the limit through legitimate use, contact your Yando administrator rather than working around it.

> **Tip:** If Claude starts adding notes one at a time and runs into the limit, ask it to "add all the notes in one go" — it has a tool for exactly that.

## Security Notes

- Your API key is never stored in plain text — it is securely hashed on the server
- Each API key only grants access to boards you own, boards shared with you, and boards in projects you belong to — with the same view/edit role you'd have in the browser
- Other users' private templates are never visible; name lookups only match built-in templates and your own
- You can revoke an API key at any time from **Settings → API Keys**
- API keys can have an expiration date for extra security
- If you suspect a key has been compromised, revoke it immediately and create a new one

## Troubleshooting

**Claude says it can't find the Yando tools:**
- Make sure your API key is valid (not expired or revoked)
- Restart your AI client after changing the configuration

**"Authentication failed" errors:**
- Verify your API key starts with `ynd_`
- Check that the key hasn't been revoked in Settings → API Keys

**"Rate limit exceeded" or 429 errors:**
- You have made more than 100 API requests in the past hour — see the **Rate Limits** section above
- Wait a few minutes and continue; the limit resets on a rolling window
- If Claude was adding sticky notes one at a time, ask it to add them all in one request instead
- If you hit this regularly through normal use, ask your administrator to exempt your account
- Make sure the MCP server URL is correct

**Objects not appearing on the board:**
- Refresh the board page — objects added via MCP appear in real time via WebSocket, but a refresh ensures everything is synced
- Check that you have editor access to the board

**Claude.ai OAuth consent page not loading:**
- Make sure the MCP server URL is correct and reachable
- Try removing and re-adding the MCP server in Claude.ai settings


---

# Keyboard Shortcuts

Press **?** on a board (or click the keyboard button in the board's header) to see these shortcuts at any time. The template editor has its own list: press **?** there, or click **⌨** next to its zoom controls.

## Canvas Navigation

| Shortcut | Action |
|----------|--------|
| **Shift + Drag** | Pan the canvas |
| **Two-finger scroll** (trackpad) | Pan the canvas |
| **Mouse Wheel** / **Pinch** | Zoom in/out |
| **Shift + Scroll** | Pan sideways |
| **Ctrl + 1** | Fit all objects in view |
| **Ctrl + +** | Zoom in |
| **Ctrl + -** | Zoom out |
| **Ctrl + 0** | Reset zoom to 100% |

On a Mac, use **⌘** wherever a shortcut says Ctrl. Hover over a toolbar button to see its shortcut.

## Object Creation

| Shortcut | Action |
|----------|--------|
| **N** | Create a sticky note (auto-enters edit mode) |
| **T** | Create a text box (auto-enters edit mode) |
| **Escape** | Finish editing / deselect |

New objects are created at the center of the current viewport. Press **Escape** when done editing to place the object.

## Editing

| Shortcut | Action |
|----------|--------|
| **Double-click** | Edit a sticky note or text box |
| **Delete** / **Backspace** | Delete selected object(s) |
| **Ctrl + Z** | Undo |
| **Ctrl + Shift + Z** | Redo |
| **Ctrl + C** | Copy selected object(s) |
| **Ctrl + V** | Paste copied object(s) |
| **Ctrl + D** | Duplicate selected object(s) |

## Selection

| Shortcut | Action |
|----------|--------|
| **Click** | Select an object |
| **Click + Drag** (on canvas) | Selection rectangle |
| **Escape** | Deselect all |

## Search & Filter

| Shortcut | Action |
|----------|--------|
| **Ctrl + F** | Open search panel |
| **Escape** | Close search panel |

The search panel lets you find objects by text content and filter by type (sticky notes, text boxes, shapes). Matching objects are highlighted and you can click results to jump to them.

## Rotation

| Shortcut | Action |
|----------|--------|
| Rotation controls in toolbar | Rotate selected object ±15 degrees |
| Precise angle input | Enter exact rotation angle |

## Other

| Shortcut | Action |
|----------|--------|
| **?** | Show keyboard shortcuts overlay |
| **M** | Toggle magnify mode (2.5x hover zoom) |

## Touch Gestures (Mobile/Tablet)

| Gesture | Action |
|---------|--------|
| **Pinch** | Zoom in/out (preserves focal point) |
| **Two-finger drag** | Pan the canvas |
| **Double-tap** | Reset zoom to 100% |
| **Long-press** | Enter edit mode on an object |
| **Single tap** | Select an object |