# UserJot documentation

> UserJot is customer feedback, public roadmap, and changelog software for SaaS teams, with live chat and a shared support inbox (Conversations) in beta. Users submit and vote on feedback, the roadmap updates itself from request status, and shipped work is announced through an AI-assisted changelog that notifies the people who asked for it.

This file contains the full text of the UserJot documentation, help center, glossary, and platform guides as plain markdown. Each page begins with a level-one heading followed by a Source line with its canonical URL. The index of product, documentation, help center, comparison, and use case pages is at https://userjot.com/llms.txt.

# Overview

Source: https://userjot.com/docs/widget-overview
Section: Widget / Getting Started
Updated: 2026-10-06

> Understand what the UserJot widget does and where it fits in your product.

The UserJot widget adds a feedback entry point directly inside your product. It
gives users one place to send feedback, check your roadmap, and read product
updates without leaving the page they are already on.

For most teams, the widget is the fastest way to bring UserJot into the product
experience. You install one script, initialize it with your project ID, and the
default launcher appears on the page.

## What the widget includes

Once installed, the widget can give users access to:

- Feedback submission
- Public roadmap
- Changelog updates
- Request voting and discussion

The exact experience depends on how your workspace is configured. For example,
if you identify users, the widget can personalize the experience. If you use
automatic login, signed-in users can move into UserJot more seamlessly across
public surfaces.

## When to use the widget

The widget is a good fit when you want feedback to stay close to the product
experience instead of sending users to a separate page first.

Common use cases:

- Add a persistent feedback entry point inside your app
- Let users check the roadmap without leaving the current page
- Make updates easier to discover from inside the product
- Replace scattered feedback channels with one consistent surface

## When to use something else

The widget is not the only way to use UserJot.

- If you want a full-page embedded experience, use an embed instead of the
  floating widget.
- If you only need to share your public board, roadmap, or changelog, a direct
  link to your UserJot site may be enough.
- If you need authentication behavior across public UserJot surfaces, that
  belongs in the authentication docs, not in the widget setup itself.

## Before you install it

You only need a few things to get started:

- A UserJot workspace
- Your project ID, which you can copy from
  **Settings** → **Login**
  in the **Secrets** section
- A place to add a script tag to your app or website

The **Share** page in the dashboard also has a
ready-made install snippet under **Widget embed** with your project ID already
filled in.

If you just want the default launcher, the initial setup is small. You can add
configuration, user identification, and custom triggers later.

## Recommended path

1. Install the widget and confirm it loads.
2. Configure the position, theme, and trigger behavior.
3. Identify signed-in users if your product has authentication.
4. Add automatic login later if you want a smoother cross-surface experience.

# Installation

Source: https://userjot.com/docs/widget-installation
Section: Widget / Getting Started
Updated: 2026-10-06

> Install the UserJot widget on your site: add the loader script, initialize with your project id, and confirm the launcher opens the board.

Installing the widget takes two steps: load the SDK, then initialize it with
your project ID.

If you use the default trigger, that is enough to make the floating launcher
appear on your page.

## 1. Add the SDK loader

Add this script near the end of your page, just before the closing
`</body>` tag:

```html
<script>
  window.$ujq = window.$ujq || [];
  window.uj =
    window.uj ||
    new Proxy(
      {},
      {
        get:
          (_, p) =>
          (...a) =>
            window.$ujq.push([p, ...a])
      }
    );
  document.head.appendChild(
    Object.assign(document.createElement('script'), {
      src: 'https://cdn.userjot.com/sdk/v2/uj.js',
      type: 'module',
      async: !0
    })
  );
</script>
```

This loader sets up the `window.uj` API and fetches the current UserJot widget
SDK from the CDN.

## 2. Initialize the widget

After the loader script, initialize UserJot with your project ID:

```html
<script>
  window.uj.init('YOUR_PROJECT_ID', {
    widget: true
  });
</script>
```

Replace `YOUR_PROJECT_ID` with the project ID from your UserJot dashboard.

The `widget: true` option enables the floating widget. If you leave it out, the
SDK can still be used for other integration modes, but the default widget will
not appear.

## Minimal working example

This is the smallest complete setup:

```html
<script>
  window.$ujq = window.$ujq || [];
  window.uj =
    window.uj ||
    new Proxy(
      {},
      {
        get:
          (_, p) =>
          (...a) =>
            window.$ujq.push([p, ...a])
      }
    );
  document.head.appendChild(
    Object.assign(document.createElement('script'), {
      src: 'https://cdn.userjot.com/sdk/v2/uj.js',
      type: 'module',
      async: !0
    })
  );
</script>
<script>
  window.uj.init('YOUR_PROJECT_ID', {
    widget: true
  });
</script>
```

## Optional: identify signed-in users

If your product already knows who the user is, you can identify them after
initialization:

```html
<script>
  window.uj.init('YOUR_PROJECT_ID', {
    widget: true
  });

  window.uj.identify({
    id: 'USER_UNIQUE_ID',
    email: 'user@example.com',
    firstName: 'John',
    lastName: 'Doe',
    avatar: 'https://example.com/avatar.jpg'
  });
</script>
```

The `id` field is required when calling `identify()`.

## Verify the install

After loading the page:

1. The widget launcher should appear on the page.
2. Clicking it should open the feedback surface.
3. You should be able to navigate between feedback, roadmap, and updates inside
   the widget.

If you are using a custom trigger instead of the default launcher, the widget
may be installed correctly even if no floating button appears.

## Common issues

### The widget does not appear

Check these first:

- The loader script is present on the page
- `window.uj.init(...)` is running after the loader snippet
- `widget: true` is included in the init options
- The project ID is valid

### The widget appears, but the user is not recognized

That usually means installation is fine, but identity is not configured yet.
Start with the [Identify users](https://userjot.com/docs/identify-users) guide. If you need
trusted cross-surface login behavior, continue with
[Automatic login](https://userjot.com/docs/automatic-login).

# Identify users

Source: https://userjot.com/docs/identify-users
Section: Widget / Integration
Updated: 2026-10-06

> Pass the signed-in user's id, name, and email to the UserJot widget so posts, votes, and chats are tied to a real account instead of an anonymous session.

Use `window.uj.identify(...)` to tell UserJot who the current signed-in user is.
Once a user is identified, the widget can personalize the experience and keep
feedback activity tied to the right person.

## Basic identification

Call `identify()` after your product knows who the current user is:

```javascript
window.uj.identify({
  id: 'user_123',
  email: 'john@example.com',
  firstName: 'John',
  lastName: 'Doe',
  avatar: 'https://example.com/avatar.jpg'
});
```

The `id` field is required. Everything else is optional, but `email` is usually
worth including.

Use your own application's user ID here. It should be the stable identifier you
assign to that user in your system, not a session ID, not a temporary token,
and not a value that changes across logins.

## When to call `identify()`

In most apps, you should identify the user when:

- the user logs in
- the app restores an existing authenticated session
- the user profile changes and you want UserJot to reflect the updated data

If the user logs out, clear the identity:

```javascript
window.uj.identify(null);
```

## What identification affects

Once a user is identified, UserJot can:

- associate feedback activity with that user
- show a more consistent signed-in experience in the widget
- carry identity into automatic login flows on public UserJot surfaces when
  automatic login is enabled

Identification is the client-side step. If you also want trusted cross-surface
authentication, use the [Automatic login docs](https://userjot.com/docs/automatic-login).

## Secure identification

If your automatic login setup requires signed tokens, include a server-generated
`signature` in the payload:

```javascript
window.uj.identify({
  id: 'user_123',
  email: 'john@example.com',
  signature: 'SERVER_GENERATED_SIGNATURE'
});
```

The signature should be created on your server, not in the browser.

## Adding traits

You can send traits along with the identified user when you already know useful
account context in your app.

```javascript
window.uj.identify({
  id: 'user_123',
  email: 'john@example.com',
  traits: {
    plan: 'pro',
    companySize: 42,
    trialing: false
  }
});
```

If you want to update one trait after identification, use `setTrait(...)`:

```javascript
window.uj.setTrait('plan', 'enterprise');
window.uj.setTrait('trialing', false);
```

## Adding company data

If your product is account-based or B2B, you can also attach company
information with the current user:

```javascript
window.uj.identify({
  id: 'user_123',
  email: 'john@example.com',
  companies: [
    {
      id: 'company_456',
      name: 'Acme Inc.',
      domain: 'acme.com',
      logo: 'https://example.com/acme-logo.png',
      traits: {
        plan: 'enterprise',
        industry: 'Software',
        companySize: 250
      }
    }
  ]
});
```

You do not need to send company data unless it is useful to your setup.

## Common app pattern

This is the usual pattern in a client app:

```javascript
if (user) {
  window.uj.identify({
    id: user.id,
    email: user.email,
    firstName: user.firstName,
    lastName: user.lastName,
    avatar: user.avatarUrl,
    signature: user.userJotSignature
  });
} else {
  window.uj.identify(null);
}
```

## Anonymous users

The widget can still work without `identify()`, but the experience is less
connected to your product account state.

For authenticated products, identifying users is usually the better default
because it reduces friction and makes UserJot activity easier to understand.

## Practical guidance

- Use stable IDs from your own system
- Identify the user only after your app session is ready
- Clear identification on logout
- Only send fields you actually need
- Keep signing logic on the server when secure mode is enabled

# Deep link to feedback

Source: https://userjot.com/docs/deep-link-feedback
Section: Widget / Integration
Updated: 2026-09-16

> Open the public feedback form directly from emails, app UI, and support replies.

Deep linking lets you send users straight to the public feedback form instead
of making them land on the board first and click a button themselves.

This is useful when you are sending people to UserJot from:

- onboarding and lifecycle emails
- support replies
- help center pages
- in-app buttons or menus

## Basic URL pattern

Add `?openFeedback` to your public feedback URL:

```text
https://yourproject.userjot.com/?openFeedback
```

If you use a custom domain:

```text
https://feedback.yourcompany.com/?openFeedback
```

When the page loads, UserJot opens the feedback submission modal and then
removes the query parameter from the URL so it does not reopen on later
navigation.

## Accepted values

The current parser treats these forms as enabled:

- `?openFeedback`
- `?openFeedback=true`
- `?openFeedback=1`
- `?openFeedback=yes`
- `?openFeedback=on`

Other values are ignored.

## Common examples

### Email CTA

```html
<a href="https://feedback.yourcompany.com/?openFeedback"> Share feedback </a>
```

### Support reply

```text
Thanks for the suggestion. Please send it here so we can track it properly:
https://feedback.yourcompany.com/?openFeedback
```

### Track campaign source

```text
https://feedback.yourcompany.com/?openFeedback&utm_source=email&utm_campaign=q2-launch
```

## Programmatic redirects from your app

If your app already loads the widget SDK, use `redirect(...)` instead of
building the URL by hand:

```javascript
window.uj.redirect();
window.uj.redirect({ openFeedback: true });
window.uj.redirect({ openFeedback: true, newTab: true });
window.uj.redirect({ to: 'updates' });
```

This is the better fit when you want UserJot to resolve the canonical public
domain automatically and attach automatic-login state when available.

## Use it with automatic login

Deep links work especially well with automatic login:

1. Identify the signed-in user in your product.
2. Send them to a UserJot link with `openFeedback`.
3. Let UserJot carry the session through automatically.

Use the implementation guide at [/docs/automatic-login](https://userjot.com/docs/automatic-login)
if you want that smoother cross-surface flow.

## Practical notes

- If guest feedback is disabled, the user may need to sign in before they can
  submit.
- The modal still respects your normal board settings and form restrictions.
- For general link placement and examples for board, roadmap, and updates
  links, use [/support/share-your-board](https://userjot.com/support/share-your-board).

# Iframe embed

Source: https://userjot.com/docs/iframe-embed
Section: Widget / Integration
Updated: 2026-09-16

> Embed the public UserJot experience directly inside your product or marketing site.

Use the iframe embed when you want the full public UserJot experience inside
your own page instead of the floating widget launcher.

This is the better fit when you want:

- a full feedback portal inside your app
- roadmap or updates embedded on a dedicated page
- your own surrounding navigation and layout

## Before you start

The embed works through the browser SDK, so load the SDK and call `init(...)`
first.

Unlike the floating widget, the embed needs a real container with an explicit
height. The iframe fills that container.

```html
<div data-userjot-embed style="width: 100%; min-height: 720px;"></div>
```

## Basic setup

Initialize the SDK, then create the embed inside `onReady`:

```html
<script>
  window.$ujq = window.$ujq || [];
  window.uj =
    window.uj ||
    new Proxy(
      {},
      {
        get:
          (_, p) =>
          (...a) =>
            window.$ujq.push([p, ...a])
      }
    );
  document.head.appendChild(
    Object.assign(document.createElement('script'), {
      src: 'https://cdn.userjot.com/sdk/v2/uj.js',
      type: 'module',
      async: !0
    })
  );
</script>
<script>
  window.uj.init('YOUR_PROJECT_ID', {
    onReady: () => {
      window.uj.embed();
    }
  });
</script>
```

Calling `embed()` before initialization finishes can fail, so `onReady` is the
safe default.

## Embed options

```javascript
const embed = window.uj.embed({
  container: '#feedback-embed',
  path: '/roadmap',
  theme: 'light',
  basePath: '/feedback',
  onReady: () => {
    console.log('Embed ready');
  },
  onError: (error) => {
    console.error('Embed failed:', error.message);
  }
});
```

### Options

- `container`: CSS selector or `HTMLElement`. Defaults to
  `[data-userjot-embed]`.
- `path`: initial path inside the public UserJot site. Defaults to `/`.
- `theme`: `'auto'`, `'light'`, or `'dark'`.
- `basePath`: enables URL syncing between your site URL and the embedded
  navigation.
- `onReady`: runs when the iframe signals that it is ready.
- `onError`: runs if the embed cannot be created.

## Programmatic control

`embed()` returns a controller:

```javascript
const embed = window.uj.embed();

embed?.navigate('/updates');
embed?.navigate('/roadmap');
embed?.destroy();
```

You can also tear down the current embed globally:

```javascript
window.uj.destroyEmbed();
```

## URL syncing

If you set `basePath`, the parent page URL stays in sync with navigation inside
the embed.

```javascript
window.uj.embed({
  basePath: '/feedback'
});
```

Examples:

- `/feedback`
- `/feedback/roadmap`
- `/feedback/updates`

Your app or site must serve the same embed page for requests under that path.
For example, if you choose `/feedback`, your router should send
`/feedback/*` to the page that contains the embed.

## Identification and authentication

The embed works with `identify(...)`, just like the widget:

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  onReady: () => {
    window.uj.identify({
      id: 'user_123',
      email: 'john@example.com'
    });

    window.uj.embed();
  }
});
```

If the user logs in later, you can identify them after the embed already
exists:

```javascript
window.uj.identify({
  id: 'user_123',
  email: 'john@example.com',
  signature: 'SERVER_GENERATED_SIGNATURE'
});
```

That lets the embed pick up the authenticated state without recreating it.

## When to use embed vs widget

- Use the widget when you want a lightweight launcher on every page.
- Use the iframe embed when you want a dedicated full-page portal inside your
  own layout.

If you only need links to your public board, roadmap, or updates pages, use
[/support/share-your-board](https://userjot.com/support/share-your-board) instead.

# Widget SDK reference

Source: https://userjot.com/docs/widget-sdk-reference
Section: Widget / Reference
Updated: 2026-08-27

> Reference for the browser SDK methods used to control the UserJot widget and public redirects.

This page documents the browser SDK exposed as `window.uj`.

If you are looking for the public REST API instead of the widget SDK, use
[/docs/api](https://userjot.com/docs/api).

## `init(projectId, options?)`

Initializes UserJot for the current page.

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  position: 'right',
  theme: 'auto',
  trigger: 'default',
  locale: 'auto',
  onReady: () => {},
  onError: (error) => {}
});
```

### Parameters

- `projectId`: your UserJot project ID
- `options.widget`: set to `true` to enable the floating widget launcher
- `options.position`: `'left'` or `'right'`
- `options.theme`: `'auto'`, `'light'`, or `'dark'`
- `options.trigger`: `'default'` or `'custom'`
- `options.locale`: `'auto'` or a locale string such as `'en-US'`
- `options.onReady`: called after initialization succeeds
- `options.onError`: called if initialization fails

## `identify(options | null)`

Identifies the current user.

```javascript
window.uj.identify({
  id: 'user_123',
  email: 'john@example.com',
  firstName: 'John',
  lastName: 'Doe',
  avatar: 'https://example.com/avatar.jpg',
  signature: 'SERVER_GENERATED_SIGNATURE',
  traits: {
    plan: 'pro',
    trialing: false
  },
  companies: [
    {
      id: 'company_456',
      name: 'Acme Inc.',
      domain: 'acme.com',
      logo: 'https://example.com/acme-logo.png',
      traits: {
        plan: 'enterprise',
        industry: 'Software',
        companySize: 250
      }
    }
  ]
});
```

### Parameters

- `id`: required stable user ID from your system
- `email`: optional email address
- `firstName`: optional first name
- `lastName`: optional last name
- `avatar`: optional avatar URL
- `signature`: optional server-generated HMAC signature
- `traits`: optional user traits object
- `companies`: optional array of company objects

Pass `null` to clear the current identity:

```javascript
window.uj.identify(null);
```

## `setTrait(key, value)`

Updates one user trait after identification.

```javascript
window.uj.setTrait('plan', 'enterprise');
window.uj.setTrait('trialing', false);
window.uj.setTrait('teamSize', 42);
window.uj.setTrait('plan', null);
```

### Parameters

- `key`: trait name
- `value`: `string`, `number`, `boolean`, or `null`

Passing `null` removes that trait key. The user must already be identified.

## `showWidget(options?)`

Opens the widget.

```javascript
window.uj.showWidget();
window.uj.showWidget({ section: 'feedback' });
window.uj.showWidget({ section: 'roadmap' });
window.uj.showWidget({ section: 'updates' });
```

### Parameters

- `options.section`: `'feedback'`, `'roadmap'`, or `'updates'`

## `hideWidget()`

Closes the widget.

```javascript
window.uj.hideWidget();
```

## `getWidgetState()`

Returns the current widget state.

```javascript
const state = window.uj.getWidgetState();
// { isOpen: boolean, section: 'feedback' | 'roadmap' | 'updates' | null }
```

## `setWidgetPosition(position)`

Moves the launcher to the left or right side of the screen.

```javascript
window.uj.setWidgetPosition('left');
window.uj.setWidgetPosition('right');
```

## `setWidgetEnabled(enabled)`

Temporarily disables or re-enables the widget launcher.

```javascript
window.uj.setWidgetEnabled(false);
window.uj.setWidgetEnabled(true);
```

## `setTheme(theme)`

Changes the widget theme after initialization.

```javascript
window.uj.setTheme('dark');
window.uj.setTheme('light');
window.uj.setTheme('auto');
```

## `askForFeedback(options?)`

Shows a toast prompt that sends the user into the feedback flow when they click
the action.

```javascript
window.uj.askForFeedback();
window.uj.askForFeedback({
  title: 'Have feedback?',
  description: 'Tell us what would make this workflow better.',
  duration: 15000
});
```

### Parameters

- `options.title`: optional toast title
- `options.description`: optional toast description
- `options.duration`: optional duration in milliseconds

## `redirect(options?)`

Redirects the user to your public UserJot site.

```javascript
window.uj.redirect();
window.uj.redirect({ to: 'roadmap' });
window.uj.redirect({ to: 'feedback', openFeedback: true });
window.uj.redirect({ to: 'updates', newTab: true });
```

### Parameters

- `options.to`: `'feedback'`, `'roadmap'`, or `'updates'`
- `options.openFeedback`: when `true`, adds the `openFeedback` query parameter
- `options.newTab`: when `true`, opens the destination in a new tab

This helper resolves the correct public domain for the current project and
automatically appends the client token when automatic login is available.

## `embed(options?)`

Embeds the public UserJot experience in an iframe and returns a controller.

```javascript
const embed = window.uj.embed({
  container: '#feedback-embed',
  path: '/roadmap',
  theme: 'auto',
  basePath: '/feedback',
  onReady: () => {},
  onError: (error) => {}
});
```

### Parameters

- `options.container`: CSS selector or `HTMLElement`
- `options.path`: initial path inside the public UserJot site
- `options.theme`: `'auto'`, `'light'`, or `'dark'`
- `options.basePath`: parent-site path prefix for URL syncing
- `options.onReady`: called when the embed is ready
- `options.onError`: called if creation fails

### Return value

`embed(...)` returns either an `EmbedController` or `null`.

```javascript
embed.navigate('/updates');
embed.destroy();
```

For the full guide, use [/docs/iframe-embed](https://userjot.com/docs/iframe-embed).

## `destroyEmbed()`

Destroys the current iframe embed instance if one exists.

```javascript
window.uj.destroyEmbed();
```

## `destroy()`

Removes the widget instance and clears its runtime state.

```javascript
window.uj.destroy();
```

This is mainly useful in environments where your page lifecycle needs to tear
down and recreate the SDK cleanly.

## `debug(options?)`

Enables debug logging and optionally overrides the API base URL.

```javascript
window.uj.debug();
```

This is primarily for development and troubleshooting.

# Configuration

Source: https://userjot.com/docs/widget-configuration
Section: Widget
Updated: 2026-10-06

> Every widget option: which panels show, how the launcher looks and where it sits, default board, language, theme, and behavior across pages and users.

The main widget configuration happens when you call `window.uj.init(...)`.
Start there for the default position, theme, trigger behavior, and locale.

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  position: 'right',
  theme: 'auto',
  trigger: 'default',
  locale: 'auto',
  onReady: () => {},
  onError: (error) => {}
});
```

## Core options

### Widget

Use `widget: true` to enable the floating widget.

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true
});
```

If you omit it, the SDK can still be used for other flows, but the default
widget launcher will not appear.

### Position

Use `position` to choose which side of the screen the launcher appears on.

Supported values:

- `'left'`
- `'right'`

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  position: 'left'
});
```

### Theme

Use `theme` to control the widget color mode.

Supported values:

- `'auto'` to follow the user or environment preference
- `'light'`
- `'dark'`

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  theme: 'dark'
});
```

### Trigger

Use `trigger` to decide whether UserJot shows the default floating launcher or
waits for your own UI to open it.

Supported values:

- `'default'`
- `'custom'`

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  trigger: 'custom'
});
```

If you use `trigger: 'custom'`, the widget is still installed, but you need to
open it from your own button or interaction.

Here is the usual pattern:

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  trigger: 'custom'
});

document
  .querySelector('[data-feedback-button]')
  ?.addEventListener('click', () => {
    window.uj.showWidget({ section: 'feedback' });
  });
```

### Locale

Use `locale` when you want to control the widget language from your product.

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  locale: 'fr-FR'
});
```

If you leave `locale` as `'auto'`, UserJot chooses the language automatically.
That is usually the right default unless your app already has a stronger source
of truth for language.

```javascript
const userLocale = getUserLocale();

window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  locale: userLocale
});
```

## Lifecycle callbacks

### onReady

Use `onReady` when you need to wait until the SDK is fully initialized before
running dependent code.

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  onReady: () => {
    console.log('UserJot is ready');
  }
});
```

### onError

Use `onError` to capture initialization failures such as configuration mistakes
or loading problems.

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  onError: (error) => {
    console.error('UserJot failed to initialize:', error.message);
  }
});
```

## Changing configuration after initialization

Some widget behavior can be updated after the initial `init()` call.

### Change the widget position

```javascript
window.uj.setWidgetPosition('left');
```

### Change the theme

```javascript
window.uj.setTheme('dark');
```

### Temporarily disable or re-enable the widget

```javascript
window.uj.setWidgetEnabled(false);
window.uj.setWidgetEnabled(true);
```

This is useful when the widget should only be available in certain parts of
your app or for certain user states.

## Programmatic control

Once the widget is initialized, you can control it from your own UI and app
logic.

### Open a specific section

```javascript
window.uj.showWidget({ section: 'feedback' });
window.uj.showWidget({ section: 'roadmap' });
window.uj.showWidget({ section: 'updates' });
```

### Close the widget

```javascript
window.uj.hideWidget();
```

### Send users to the public UserJot site instead

If you want a full-page public experience instead of opening the floating
widget, use `redirect(...)`:

```javascript
window.uj.redirect({ to: 'feedback' });
window.uj.redirect({ to: 'feedback', openFeedback: true });
window.uj.redirect({ to: 'updates', newTab: true });
```

That is useful when your product has both an in-app widget and public UserJot
pages.

## Common configuration patterns

### Minimal setup

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true
});
```

### Match the app theme automatically

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  theme: 'auto'
});
```

### Use your own launcher

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  trigger: 'custom'
});
```

### Force a specific locale

```javascript
window.uj.init('YOUR_PROJECT_ID', {
  widget: true,
  locale: 'en-US'
});
```

## How to think about configuration

Use `init()` for the default behavior you want on first load.

Use runtime methods such as `setTheme`, `setWidgetPosition`, and
`setWidgetEnabled` when the widget needs to react to app state after the page
has already loaded.

If you want a full page embedded experience instead of the floating widget, use
the iframe guide at [/docs/iframe-embed](https://userjot.com/docs/iframe-embed).

If you want the full SDK surface area in one place, use
[/docs/widget-sdk-reference](https://userjot.com/docs/widget-sdk-reference).

# Overview

Source: https://userjot.com/docs/widget-v3-overview
Section: Widget v3 / Getting Started
Updated: 2026-10-06

> What the new UserJot widget (v3, in beta) includes: feedback, roadmap, changelog, and live chat in one in-app surface, with a smaller SDK and a new API.

The new UserJot widget is a complete in-app surface for your product. It puts
feedback, your roadmap, product updates, and direct messages behind a single
launcher on your site.

It is available in beta today.

## What beta means

The API documented in this section is stable. We will add new capabilities
over time, but we will not rename methods or change how they behave. You can
build on it now without worrying about breaking changes.

Beta means the widget itself is new and improving quickly. If you run into
anything odd, we want to hear about it.

## What the widget includes

- **Home**: a starting point that surfaces what matters to the current user.
- **Feedback**: browse, search, vote, and submit feedback without leaving your app.
- **Roadmap**: see what is planned and in progress.
- **Updates**: read your changelog, with an unread indicator on the launcher.
- **Messages**: direct conversations between your users and your team. This
  surface appears once Conversations is enabled in your workspace settings,
  and it is exclusive to widget v3.
- **Notifications**: activity on posts the user follows.

## Feedback and moderation

Feedback submitted through the widget follows your workspace's moderation
settings. A receipt confirms that the feedback was saved; it may still need
checking or approval before it appears on the public board.

Your team can review it in the dashboard. See
[moderate content](https://userjot.com/support/moderate-content) for the available settings and
review actions.

## What you can build with it

The widget works with a single copy-paste install, but the SDK gives you full
programmatic control:

- Open any section of the widget from your own UI with [`open()`](https://userjot.com/docs/widget-v3-control).
- Replace the default launcher with your own button, including a live unread
  badge.
- Identify signed-in users, with optional [signed identity](https://userjot.com/docs/widget-v3-signed-identity)
  using a JWT from your server.
- React to widget events like open, close, and new unread activity.
- [Embed full pages inline](https://userjot.com/docs/widget-v3-embed) instead of using the floating widget.

## Recommended path

1. [Install the widget](https://userjot.com/docs/widget-v3-installation). This takes a few minutes.
2. [Identify your users](https://userjot.com/docs/widget-v3-identify) so feedback and messages are
   tied to real accounts.
3. Set up [signed identity](https://userjot.com/docs/widget-v3-signed-identity) when you are ready
   to verify users server-side.
4. Use [programmatic control](https://userjot.com/docs/widget-v3-control) and
   [embeds](https://userjot.com/docs/widget-v3-embed) to go deeper.

The full API is documented in the [SDK reference](https://userjot.com/docs/widget-v3-reference).

# Installation

Source: https://userjot.com/docs/widget-v3-installation
Section: Widget v3 / Getting Started
Updated: 2026-10-06

> Install UserJot widget v3 with two script tags, a loader stub and the module, then confirm the launcher opens and calls made before load are replayed.

Installing the widget takes one snippet. Paste it near the end of your page,
just before the closing `</body>` tag:

```html
<script>
  window.uj ||= new Proxy(
    {},
    {
      get: (_, p) =>
        p == 'then'
          ? 0
          : (...a) => {
              (window.$ujq ||= []).push([p, ...a]);
            }
    }
  );
  uj.init('YOUR_PROJECT_ID');
</script>
<script type="module" async src="https://cdn.userjot.com/sdk/v3/uj.js"></script>
```

Replace `YOUR_PROJECT_ID` with the project ID from your UserJot dashboard.

That is the whole install. The launcher appears in the bottom right corner of
your page.

The first script sets up `window.uj` and queues any calls you make. The second
script loads the SDK, which then replays those calls. This means you never have
to wait for the SDK to load before calling it.

## Call order does not matter

You can call `init`, `identify`, and `open` on the same tick, in any order
relative to the SDK loading. The SDK queues everything and runs it once ready.

```html
<script>
  window.uj ||= new Proxy(
    {},
    {
      get: (_, p) =>
        p == 'then'
          ? 0
          : (...a) => {
              (window.$ujq ||= []).push([p, ...a]);
            }
    }
  );
  uj.init('YOUR_PROJECT_ID');
  uj.identify({ user: { id: 'user-123', email: 'user@example.com' } });
</script>
<script type="module" async src="https://cdn.userjot.com/sdk/v3/uj.js"></script>
```

## No inline scripts (strict CSP)

If your site does not allow inline scripts, use the single-tag install instead.
Put your project ID in the `data-project` attribute and the SDK initializes
itself:

```html
<script
  type="module"
  async
  src="https://cdn.userjot.com/sdk/v3/uj.js"
  data-project="YOUR_PROJECT_ID"
></script>
```

With this variant you can still call `window.uj` methods from your own scripts
after the SDK loads. If you also call `uj.init(...)` yourself, your call wins
and the attribute is ignored.

## Configuration

Pass options as the second argument to `init`:

```javascript
uj.init('YOUR_PROJECT_ID', {
  widget: {
    position: 'right', // 'left' or 'right'
    theme: 'auto', // 'auto', 'light', or 'dark'
    launcher: true // false hides the default button
  },
  locale: 'en-US' // optional, defaults to your workspace language settings
});
```

Everything is optional. `uj.init('YOUR_PROJECT_ID')` with no options shows the
default launcher on the right with automatic theming.

Set `launcher: false` when you want to open the widget from your own button
instead of the default one. See
[Controlling the widget](https://userjot.com/docs/widget-v3-control) for a full example.

## Verify the install

After loading the page:

1. The launcher button appears on your page.
2. Clicking it opens the widget.
3. You can move between feedback, roadmap, and updates inside the widget.

If your workspace has Conversations enabled, the Messages surface appears in
the widget as well, with no extra installation.

## Common issues

### The widget does not appear

Check these first:

- Both script tags are on the page, or the single tag with `data-project`.
- The project ID is correct.
- You did not pass `widget: false` or `launcher: false` in the init options.

### Calls seem to do nothing

If you call `uj.open()` or `uj.identify(...)` and nothing happens, make sure
`uj.init(...)` runs somewhere on the page. Calls made before `init` wait until
`init` happens. The SDK logs a warning in the console if calls are pending and
`init` never ran.

## Next step

Tie the widget to your signed-in users with
[Identify users](https://userjot.com/docs/widget-v3-identify).

# Identify users

Source: https://userjot.com/docs/widget-v3-identify
Section: Widget v3 / Identity
Updated: 2026-10-06

> Tell widget v3 who the current user is with uj.identify, so their posts, votes, and chats are tied to an account and persist across sessions.

By default, the widget treats every visitor as anonymous. Call `identify` to
tell UserJot who the current user is. Their feedback, votes, and messages are
then tied to their account.

## Basic identification

```javascript
uj.identify({
  user: {
    id: 'user-123',
    email: 'ada@example.com',
    firstName: 'Ada',
    lastName: 'Lovelace',
    avatar: 'https://example.com/avatar.jpg'
  }
});
```

`user.id` is required. Use a stable ID from your own system, like your database
user ID. Do not use values that can change, like an email address or a display
name.

Everything else is optional, but `email` is strongly recommended. It makes the
identity easier to reconcile across UserJot surfaces.

## When to call identify

Call `identify` once your app knows who the user is, usually right after your
session loads. Calling it again with the exact same input is safe; the SDK
skips the duplicate call as long as that session is still live. Once the
session expires, the same input triggers a fresh call. Changing anything in
the payload, including traits or email, always sends a fresh call, and a
different user switches the session to that user.

When the user logs out of your app, call `logout`:

```javascript
uj.logout();
```

A typical pattern:

```javascript
if (user) {
  uj.identify({
    user: {
      id: user.id,
      email: user.email,
      firstName: user.firstName,
      lastName: user.lastName
    }
  });
} else {
  uj.logout();
}
```

## Adding traits

Traits are custom attributes you attach to a user. They show up alongside the
user in your dashboard and help you understand who is asking for what.

```javascript
uj.identify({
  user: {
    id: 'user-123',
    email: 'ada@example.com',
    traits: {
      plan: 'pro',
      seats: 12,
      trialing: false
    }
  }
});
```

Trait values can be strings, numbers, booleans, or `null`.

## Adding companies

If your product is B2B, you can attach the user's companies:

```javascript
uj.identify({
  user: { id: 'user-123', email: 'ada@example.com' },
  companies: [
    {
      id: 'acme',
      name: 'ACME Inc.',
      domain: 'acme.com',
      traits: { plan: 'enterprise' }
    }
  ]
});
```

`id` is required for each company. Use a stable ID from your own system.

## What identify returns

`identify` returns a promise with the result:

```javascript
const result = await uj.identify({
  user: { id: 'user-123', email: 'ada@example.com' }
});

result.viewer; // the identified user, or null
result.identityTrust; // 'signed' or 'unsigned'
result.warnings; // anything the server ignored or adjusted
```

Check `warnings` during development. For example, if you send a field the
server does not support, the warning tells you which one.

## Identity and conversations

If Conversations is enabled, identity changes how the Messages surface
behaves:

- Identified users skip the visitor-details prompt entirely. Replies from your
  team reach them at their account email.
- Anonymous visitors get guest conversations scoped to their browser, with
  optional contact capture depending on your widget settings.

One subtlety: if your workspace requires signed tokens, an unsigned `identify`
does not work at all. The server rejects it with HTTP 403, the promise rejects
with an `IDENTIFY_FAILED` error, and nothing from the call is applied — the
visitor stays anonymous, with no prefilled contact details. Use
[signed identity](https://userjot.com/docs/widget-v3-signed-identity) to attach conversations to
verified accounts.

## Verified identity

A plain `identify` call is unsigned. It comes from the browser, so it can be
tampered with. That is fine for many products, but if you want UserJot to trust
the identity, or you want to require it, have your server sign the identity as
a JWT.

That is covered in [Signed identity](https://userjot.com/docs/widget-v3-signed-identity).

# Signed identity

Source: https://userjot.com/docs/widget-v3-signed-identity
Section: Widget v3 / Identity
Updated: 2026-10-06

> Verify who the user is in widget v3 by signing an identity token on your server with your secret, so nobody can impersonate another user from the browser.

A plain `identify` call comes from the browser, so anyone can change it.
Signed identity fixes that. Your server creates a short-lived JWT that proves
who the user is, and the widget sends it to UserJot.

With a signed identity, everything in the token is verified: the user ID,
email, name, traits, and companies. Nothing can be spoofed from the browser.

## When you need this

- You want to trust that feedback and messages really come from the user they
  claim to come from.
- You enabled **Require signed tokens** in your
  workspace settings. Unsigned identify calls are then rejected.
- Workspace admins and owners always need a signed identity. Unsigned
  identification is never accepted for privileged accounts.

## 1. Create the token on your server

Sign a JWT with the **HS256** algorithm using your workspace secret. You can
find both values in **Settings** →

**Login**, in the **Secrets** section, listed as
**Project ID** and
**Project secret**.

Never sign tokens in the browser. The secret must stay on your server.

The token must include these claims:

| Claim | Value                                                          |
| ----- | -------------------------------------------------------------- |
| `sub` | The user's ID in your system. Required.                        |
| `iss` | Your UserJot project ID. Required.                             |
| `aud` | The exact string `userjot`. Required.                          |
| `iat` | Issued at, in Unix seconds. Required.                          |
| `exp` | Expiry, in Unix seconds. Required. Maximum 1 hour after `iat`. |

You can also include these optional claims: `email`, `firstName`, `lastName`,
`avatar`, `traits`, and `companies`. Anything you put in the token is treated
as verified.

```javascript title="Node.js"
import jwt from 'jsonwebtoken';

export function createUserJotToken(user, secret, projectId) {
  return jwt.sign(
    {
      sub: user.id,
      email: user.email,
      firstName: user.firstName,
      lastName: user.lastName,
      iss: projectId,
      aud: 'userjot'
    },
    secret,
    { algorithm: 'HS256', expiresIn: '1h' }
  );
}
```

```python title="Python"
import time
import jwt

def create_userjot_token(user, secret, project_id):
    now = int(time.time())
    return jwt.encode(
        {
            "sub": user["id"],
            "email": user["email"],
            "firstName": user["first_name"],
            "lastName": user["last_name"],
            "iss": project_id,
            "aud": "userjot",
            "iat": now,
            "exp": now + 3600,
        },
        secret,
        algorithm="HS256",
    )
```

```php title="PHP"
<?php

use Firebase\JWT\JWT;

function createUserJotToken(array $user, string $secret, string $projectId): string
{
    $now = time();

    return JWT::encode([
        'sub' => $user['id'],
        'email' => $user['email'],
        'firstName' => $user['firstName'],
        'lastName' => $user['lastName'],
        'iss' => $projectId,
        'aud' => 'userjot',
        'iat' => $now,
        'exp' => $now + 3600,
    ], $secret, 'HS256');
}
```

```ruby title="Ruby"
require 'jwt'

def create_userjot_token(user, secret, project_id)
  now = Time.now.to_i

  payload = {
    sub: user[:id],
    email: user[:email],
    firstName: user[:first_name],
    lastName: user[:last_name],
    iss: project_id,
    aud: 'userjot',
    iat: now,
    exp: now + 3600
  }

  JWT.encode(payload, secret, 'HS256')
end
```

Create a fresh token on each page load, for example when you render the page
or through a small endpoint your frontend calls. Tokens are capped at 1 hour,
so do not cache them for longer.

## 2. Pass the token to identify

Send the token in the `token` field:

```javascript
uj.identify({
  token: 'TOKEN_FROM_YOUR_SERVER'
});
```

You can still pass `user` and `companies` alongside the token. They are used
as extra, unverified detail. If a field appears in both, the token wins:

```javascript
uj.identify({
  token: 'TOKEN_FROM_YOUR_SERVER',
  user: { id: 'user-123' },
  companies: [{ id: 'acme', name: 'ACME Inc.' }]
});
```

You can confirm the identity was verified from the result:

```javascript
const result = await uj.identify({ token });
result.identityTrust; // 'signed'
```

## Invalid tokens fail, they do not fall back

If the token is expired, malformed, or signed with the wrong secret, the
`identify` call rejects with `IDENTIFY_FAILED`. It does not silently continue
as an unsigned identity. This is deliberate: a broken signing setup should be
loud, not invisible.

## Signed identity and conversations

Signed identity is what attaches widget conversations to a verified account.
Two behaviors are worth knowing:

- If a visitor starts a conversation anonymously and then identifies with a
  signed token, their guest conversation is handed off to the member account,
  so history follows them.
- A conversation started under a signed identity stays protected. Opening it
  later without a signed session shows "Verify to view this conversation"
  until they identify again with a signed token.

Requiring signed tokens does not close the door on anonymous visitors: they
can still start guest conversations scoped to their browser. What strict mode
changes is that a conversation can only be attached to a member account
through a signed token — unsigned `identify` calls are rejected outright.

## Identity carries over to your public pages

Once a user is identified, the SDK automatically attaches the identity to
links from your product that point to your public UserJot pages, like your
board, roadmap, or changelog. For the user to land there already signed in,
your workspace also needs **Automatic login** enabled in settings — that is
the mechanism the public pages use to accept the identity. Without it, the
links still work but the user arrives signed out.

## Troubleshooting

### The identify call rejects with IDENTIFY_FAILED

Check these:

- The token is signed with HS256 and your current workspace secret.
- `iss` matches your project ID and `aud` is exactly `userjot`.
- Both `iat` and `exp` are present, in Unix seconds.
- The lifetime is 1 hour or less. Longer tokens are rejected.
- Your server clock is accurate. Tokens issued in the future are rejected,
  with 60 seconds of allowed clock skew.

### Unsigned identify stopped working

That usually means **Require signed tokens** was
enabled for your workspace. You can find it in

**Settings** → **Login**,
where it appears once **Automatic login** is on. Once
it is enabled, every identify call needs a token.

# Controlling the widget

Source: https://userjot.com/docs/widget-v3-control
Section: Widget v3 / Guides
Updated: 2026-09-16

> Open the widget programmatically, listen to events, and build a custom launcher.

The widget works on its own, but you can also drive it from your own UI. Open
specific sections, react to events, and replace the launcher entirely.

## Opening the widget

`open()` with no arguments opens the widget where the user left off:

```javascript
uj.open();
```

Pass a target to open a specific place:

```javascript
uj.open({ to: 'home' });
uj.open({ to: 'feedback' });
uj.open({ to: 'roadmap' });
uj.open({ to: 'updates' });
uj.open({ to: 'messages' });
uj.open({ to: 'notifications' });
```

Some targets accept extra options:

```javascript
// Open the feedback submission form directly
uj.open({ to: 'feedback', compose: true });

// Open a specific feedback post
uj.open({ to: 'feedback', submissionId: 'POST_ID' });

// Open a specific changelog update
uj.open({ to: 'updates', updateId: 'UPDATE_ID' });

// Start a message with prefilled text
uj.open({ to: 'messages', compose: { text: 'I need help with...' } });
```

`close()` hides the widget and `toggle()` switches between open and closed:

```javascript
uj.close();
uj.toggle();
```

These are useful anywhere in your product. For example, a "Give feedback" item
in your account menu can call `uj.open({ to: 'feedback', compose: true })`, or
a "Contact us" button can call `uj.open({ to: 'messages' })`.

The `messages` target requires Conversations to be enabled in your workspace.
If it is not, the call reports a `CONVERSATIONS_DISABLED` error through the
`error` event and opens Home instead.

## Listening to events

Subscribe with `on`. It returns a function that removes the listener:

```javascript
const unsubscribe = uj.on('open', () => {
  console.log('widget opened');
});

// later
unsubscribe();
```

Available events:

| Event         | When it fires                                                                    |
| ------------- | -------------------------------------------------------------------------------- |
| `ready`       | The SDK finished loading. Fires immediately if already loaded.                   |
| `open`        | The widget became visible.                                                       |
| `close`       | The widget was hidden.                                                           |
| `identify`    | The identity changed, including logout.                                          |
| `unread`      | The unread count changed. Payload is `{ count }`.                                |
| `presence`    | Team availability changed. Payload is `{ availability: 'online' \| 'neutral' }`. |
| `statechange` | Any part of the widget state changed.                                            |
| `error`       | Something went wrong. Payload is the error.                                      |

## Reading state

`getState()` returns a snapshot of the current widget state:

```javascript
const state = uj.getState();

state.status; // 'ready' once the SDK is loaded
state.widget.open; // is the widget visible right now
state.unreadCount; // number, or null before the first fetch
state.presence; // 'online' when someone from the team is online
state.session.status; // 'anonymous', 'identifying', or 'identified'
state.session.viewer; // the identified user, or null
```

## Building your own launcher

The flagship use case: hide the default button and use your own, with a live
unread badge.

First, disable the default launcher:

```javascript
uj.init('YOUR_PROJECT_ID', {
  widget: { launcher: false }
});
```

Hiding the launcher removes the button, but notification whispers — the small
toasts announcing a new changelog post or a reply — keep appearing in the
widget corner. That is deliberate: your button replaces the entry point, not
the widget. See [Whispers](#whispers) below for how to move or disable
them.

Then wire up your button:

```javascript
const button = document.querySelector('#feedback-button');
const badge = document.querySelector('#feedback-badge');

button.addEventListener('click', () => uj.toggle());

uj.on('unread', ({ count }) => {
  badge.textContent = count > 0 ? String(count) : '';
});
```

You can also mirror the widget's green "team is online" dot:

```javascript
const dot = document.querySelector('#feedback-online-dot');

uj.on('presence', ({ availability }) => {
  dot.hidden = availability !== 'online';
});
```

`'neutral'` means the SDK cannot currently prove anyone is online — it never
claims the team is offline, so hide the dot rather than showing an "offline"
state. Read `uj.getState().presence` for the initial value.

While the widget is closed, presence refreshes on page load, on tab focus,
and every few minutes in between — so treat `'online'` as "online as of the
latest check". While the widget is open it updates live.

That is all. The badge and dot update when new updates are published, new
messages arrive, or team availability changes, the same way the default
launcher does. Subscribing to either event keeps the data flowing in the
background.

The unread count includes conversation replies alongside changelog and
feedback notifications. When the user opens the widget with conversation
unread pending, it lands on Messages first so the reply is the first thing
they see.

If you just want the default launcher to open from an existing element on your
page, you can also pass a selector instead of building it yourself:

```javascript
uj.init('YOUR_PROJECT_ID', {
  widget: { launcher: { selector: '#feedback-button' } }
});
```

## Whispers

Whispers are ephemeral toasts near the widget corner: "New: Dark mode is
live", "Sarah replied to your idea". They appear for a few seconds, are
clickable (opening the widget at the exact item), and dismiss themselves.

Whispers announce changelog posts and feedback notifications. Conversation
replies do not whisper; they light up the unread count instead.

They are independent of the launcher. With the default launcher, whispers
expand out of the button itself. With `launcher: false` or a selector
launcher, they appear on their own in the corner — no button, no unread dot,
nothing while idle.

If your own button lives in the same corner, move the whisper surface out of
its way with `offset`:

```javascript
uj.init('YOUR_PROJECT_ID', {
  widget: {
    launcher: false,
    offset: { bottom: 84 } // pixels from the bottom edge; `side` works too
  }
});
```

To turn whispers off entirely — for example if you render your own
notifications from the `unread` event — disable them explicitly:

```javascript
uj.init('YOUR_PROJECT_ID', {
  widget: { launcher: false, whispers: false }
});
```

With both disabled and no explicit update notification mode, the widget renders
nothing until you call `uj.open()`.
Note that `unread` and `presence` events keep working either way as long as
you are subscribed.

## Update announcements

Choose how the widget announces the latest unseen changelog entry with
`widget.notifications.updates`:

```javascript
uj.init('YOUR_PROJECT_ID', {
  widget: {
    notifications: { updates: 'full' }
  }
});
```

| Mode        | Behavior                                                                                      |
| ----------- | --------------------------------------------------------------------------------------------- |
| `'whisper'` | Announces the update in a corner toast using the existing repeat limits.                      |
| `'full'`    | Opens the update directly in the widget reader, including its cover image and full content.   |
| `'none'`    | Suppresses update announcements while keeping the updates section and unread badge available. |

If you omit the setting, updates use `'whisper'` unless `whispers: false`,
which defaults updates to `'none'`. An explicit update mode takes precedence
for changelog announcements only. Feedback whispers still follow `whispers`,
and conversation replies still contribute to unread independently.

Full announcements work with a hidden or custom launcher and no event
subscriptions. For example, this configuration opens unseen updates without
showing a launcher or other whispers:

```javascript
uj.init('YOUR_PROJECT_ID', {
  widget: {
    launcher: false,
    whispers: false,
    notifications: { updates: 'full' }
  }
});
```

On a first visit, full mode can show the latest published entry even if it is
old. The SDK attempts at most one automatic opening per initialization visit.
A manual open, toggle, or close prevents further automatic opening during that
visit. A failed or interrupted attempt also spends that allowance. Reloading
or calling `init()` again starts a new visit; changing identity or navigating
your app does not.

Automatic opening waits for a visible, focused page and a closed widget.
Losing focus or closing the widget during loading cancels that attempt.
`widget: false` disables automatic presentation entirely.

An article becomes seen when its content is mounted in the shown widget on a
visible, focused page. This applies to manual and automatic views. A click,
prefetch, failed load, or hidden article does not mark it seen. Reading an
older entry does not consume a newer unread update. An entry with the stored
seen ID stays seen if it is edited or republished.

Seen history is stored for the project in this host origin's browser storage.
It is not synchronized across users, devices, browsers, or origins. Clearing
or blocking storage can allow another announcement on a later visit, and
simultaneous tabs can race.

Updates are discovered through the existing attention checks on initialization,
focus, and roughly every five minutes while the widget is closed. Publishing
an entry does not immediately push it into every open page.

## Changing the language

The widget picks a language automatically. To set it yourself:

```javascript
uj.init('YOUR_PROJECT_ID', { locale: 'fr-FR' });
```

You can change it later without reloading:

```javascript
await uj.setLocale('de-DE');
```

# Embedding pages inline

Source: https://userjot.com/docs/widget-v3-embed
Section: Widget v3 / Guides
Updated: 2026-09-16

> Render your feedback board, roadmap, or changelog inside your own pages.

Embeds render your UserJot pages inside your own layout instead of a floating
widget. Use them when you want a full feedback page, roadmap, or changelog as
part of your site or app.

Embeds cover your public pages: the board, roadmap, and changelog. The
Messages surface from Conversations lives in the widget only and cannot be
embedded.

## Basic setup

Add a container element to your page:

```html
<div data-userjot-embed style="height: 700px"></div>
```

Then create the embed:

```javascript
uj.init('YOUR_PROJECT_ID', { widget: false });
uj.createEmbed();
```

The embed fills its container, so size the container with your own CSS.

`widget: false` turns off the floating widget. You can also keep both: the
embed and the widget work independently.

## Options

```javascript
uj.createEmbed({
  container: '#my-container', // selector or element, default '[data-userjot-embed]'
  path: '/roadmap', // which page to show first, default '/'
  theme: 'auto' // 'auto', 'light', or 'dark'
});
```

## Controlling an embed

`createEmbed` returns a controller:

```javascript
const embed = uj.createEmbed({ path: '/' });

embed.navigate('/roadmap'); // change the page
embed.destroy(); // remove the embed
```

## Syncing with your URL

If the embed should feel like part of your app's routing, pass `basePath`.
The embed then keeps your browser URL in sync as the user moves around:

```javascript
uj.createEmbed({
  container: '#feedback-page',
  basePath: '/feedback'
});
```

With this setup, when a user opens a post inside the embed, your URL becomes
`/feedback/board/p/some-post`, and loading that URL directly opens the embed
on that post.

For deep links to work, your router must serve the embed page for the base
path and everything under it. With `basePath: '/feedback'`, both `/feedback`
and `/feedback/*` should render the page that calls `createEmbed`.

## Identity flows in automatically

If you call `identify`, every embed picks up the identity automatically,
including embeds created later. On `logout`, embeds are signed out too. You do
not need to wire anything.

One requirement: signing users into embedded pages runs through
[Automatic login](https://userjot.com/docs/automatic-login), so it has to be enabled in your
workspace settings. Without it, the server rejects the sign-in exchange and
the embed loads signed out, even with a valid signed identity.

```javascript
uj.identify({ token: 'TOKEN_FROM_YOUR_SERVER' });
uj.createEmbed(); // this embed starts already signed in
```

## Multiple embeds

You can create more than one embed on the same page, each with its own
container and page:

```javascript
uj.createEmbed({ container: '#board', path: '/' });
uj.createEmbed({ container: '#roadmap', path: '/roadmap' });
```

## Embed or widget?

- Use the **widget** when feedback should be available everywhere in your app
  with one click.
- Use an **embed** when you want a dedicated page, like `yourapp.com/feedback`,
  that renders UserJot inside your own layout.

Many products use both: the widget across the app, and an embedded board on a
dedicated page.

# SDK reference

Source: https://userjot.com/docs/widget-v3-reference
Section: Widget v3 / Reference
Updated: 2026-10-06

> Complete reference for the widget v3 window.uj API: every method, option, event, and error, with signatures and the state each one expects.

The SDK is exposed as `window.uj`. All methods can be called at any time, even
before the SDK has loaded. Calls are queued and run once ready.

## uj.version

The SDK version as a string, for example `1.0.0-beta.1`.

## uj.init(projectId, options?)

Initializes the SDK. Returns a promise that resolves with the SDK state once
loading settles.

```javascript
const state = await uj.init('YOUR_PROJECT_ID', {
  widget: {
    launcher: true, // boolean or { selector: string }
    whispers: true, // default whisper behavior
    notifications: { updates: 'whisper' }, // 'whisper', 'full', or 'none'
    position: 'right', // 'left' or 'right'
    offset: { bottom: 20 }, // corner distance in pixels: { bottom, side }
    theme: 'auto' // 'auto', 'light', or 'dark'
  },
  locale: 'en-US', // optional language override
  pageContext: 'origin', // 'origin', 'path', or 'none'
  onReady: () => {},
  onError: (error) => {}
});
```

| Option                         | Default                                         | Description                                                                                                                                                                                                                                                                                                 |
| ------------------------------ | ----------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `widget`                       | `true`                                          | `true` shows the widget with defaults. `false` disables it. An object configures it.                                                                                                                                                                                                                        |
| `widget.launcher`              | `true`                                          | `false` hides the default button. `{ selector }` binds the widget to your own element.                                                                                                                                                                                                                      |
| `widget.whispers`              | `true`                                          | Ephemeral notification toasts at the widget corner. Independent of the launcher: they keep appearing when the button is hidden unless set to `false`. An explicit update notification mode overrides this for changelog announcements only. See [Controlling the widget](https://userjot.com/docs/widget-v3-control#whispers). |
| `widget.notifications.updates` | `'whisper'`, or `'none'` when `whispers: false` | `'whisper'` announces updates in a toast; `'full'` opens the latest unseen entry in the existing reader; `'none'` suppresses update announcements while preserving unread. Explicit values override `whispers` for updates only.                                                                            |
| `widget.position`              | `'right'`                                       | Which side of the screen the widget opens on.                                                                                                                                                                                                                                                               |
| `widget.offset`                | `{ bottom: 20, side: 20 }`                      | Pixel distance of the launcher and whispers from the viewport edges. Useful when your own button occupies the corner.                                                                                                                                                                                       |
| `widget.theme`                 | `'auto'`                                        | Follow the system, or force light or dark.                                                                                                                                                                                                                                                                  |
| `locale`                       | workspace setting                               | Language, for example `'fr-FR'`.                                                                                                                                                                                                                                                                            |
| `pageContext`                  | `'origin'`                                      | How much of the current page URL is shared with your team in conversations. `'origin'` sends the domain, `'path'` includes the path, `'none'` sends nothing.                                                                                                                                                |
| `onReady`                      |                                                 | Called when the SDK is ready.                                                                                                                                                                                                                                                                               |
| `onError`                      |                                                 | Called on any SDK error.                                                                                                                                                                                                                                                                                    |

The returned promise does not reject on network problems. Check
`state.status === 'ready'` if you need to confirm loading succeeded. It rejects
only for programmer errors: an empty project ID or malformed options.

An empty `notifications` object or `updates: undefined` uses the default.
Malformed notification objects, unknown keys, and values outside `'whisper'`,
`'full'`, and `'none'` reject initialization with `INVALID_OPTIONS` and
`recoverable: false` before network or DOM work.

Full mode works without a launcher, other whispers, or host subscriptions.
It can show an old latest entry on the first visit and attempts one automatic
opening per initialization. Manual open, toggle, or close spends that visit's
allowance too. Failed or cancelled attempts are not retried during that visit.
Identity changes and app navigation do not reset it; reload or reinitialization
does. `widget: false` disables automatic presentation.

Opening requires a visible, focused page and a closed widget. An actual visible
article view, through any entry point, records the article as seen. Prefetches,
clicks alone, hidden content, and failed loads do not. Reading older content
cannot consume a newer release. Seen history is browser-local and scoped by
project and host origin, with no cross-device or cross-tab delivery guarantee.
Checks use initialization, focus, and the existing roughly five-minute
closed-widget poll. See [Update announcements](https://userjot.com/docs/widget-v3-control#update-announcements)
for examples and storage limits.

## uj.ready()

Returns the same promise as `init`. Useful when the code that needs the SDK is
far away from the code that initialized it.

```javascript
const state = await uj.ready();
```

## uj.identify(input)

Identifies the current user. Returns a promise with the result. See
[Identify users](https://userjot.com/docs/widget-v3-identify) and
[Signed identity](https://userjot.com/docs/widget-v3-signed-identity).

```javascript
const result = await uj.identify({
  token: 'OPTIONAL_JWT_FROM_YOUR_SERVER',
  user: {
    id: 'user-123', // required if no token is given
    email: 'ada@example.com',
    firstName: 'Ada',
    lastName: 'Lovelace',
    avatar: 'https://example.com/avatar.jpg',
    traits: { plan: 'pro' }
  },
  companies: [{ id: 'acme', name: 'ACME Inc.', domain: 'acme.com', traits: {} }]
});

result.viewer; // the identified user, or null (shape below)
result.identityTrust; // 'signed', 'unsigned', or null
result.warnings; // [{ code, message, field? }]
```

`viewer` has this shape:

```javascript
{
  id: 'mem_...',        // UserJot's member ID, not the user.id you sent
  firstName: 'Ada',     // string or null
  lastName: 'Lovelace', // string or null
  avatar: { url: 'https://...', blurhash: '...' } // or null; blurhash optional
}
```

At least one of `token` or `user.id` is required. Calling `identify` again
with the same input is a no-op while the resulting session is still live;
after it expires, the same input is sent again. Calling it with new input
switches the session. If several calls overlap, the last one wins.

This is the only method that rejects on runtime failures, with
`IDENTIFY_FAILED`.

## uj.logout()

Clears the current identity and returns the session to anonymous.

```javascript
await uj.logout();
```

## uj.open(target?)

Opens the widget. With no argument, opens where the user left off. Resolves
when the widget is visible.

```javascript
await uj.open();
await uj.open({ to: 'home' });
await uj.open({ to: 'feedback' });
await uj.open({ to: 'feedback', compose: true });
await uj.open({ to: 'feedback', submissionId: 'POST_ID' });
await uj.open({ to: 'roadmap' });
await uj.open({ to: 'updates' });
await uj.open({ to: 'updates', updateId: 'UPDATE_ID' });
await uj.open({ to: 'messages' });
await uj.open({ to: 'messages', compose: { text: 'Prefilled message' } });
await uj.open({ to: 'notifications' });
```

Rejects with `INVALID_NAVIGATION` for unknown targets or invalid combinations,
like passing both `submissionId` and `compose`.

## uj.close()

Hides the widget. Synchronous. Safe to call at any time.

## uj.toggle()

Opens the widget if closed, closes it if open.

## uj.createEmbed(options?)

Renders a UserJot page inside a container on your page. Returns a controller.
See [Embedding pages inline](https://userjot.com/docs/widget-v3-embed).

```javascript
const embed = uj.createEmbed({
  container: '[data-userjot-embed]', // selector or element
  path: '/', // initial page
  basePath: '/feedback', // sync with your browser URL
  theme: 'auto',
  onReady: () => {},
  onError: (error) => {}
});

embed.navigate('/roadmap');
embed.destroy();
```

Multiple embeds can exist at the same time. All of them follow the current
identity.

## uj.setLocale(locale)

Changes the widget language at runtime.

```javascript
await uj.setLocale('de-DE');
```

## uj.setTheme(theme)

Changes the widget theme at runtime. Accepts `'auto'`, `'light'`, or `'dark'`.
Synchronous, unlike `setLocale`.

```javascript
uj.setTheme('dark');
```

Invalid values report `INVALID_OPTIONS` through the `error` event without
changing the theme. Note that `init` always applies its own theme, which
defaults to `'auto'` when you do not pass one, so a `setTheme` call made
before `init` does not survive it. Pass the theme in the `init` options
instead.

## uj.getState()

Returns a read-only snapshot of the SDK state.

```javascript
{
  status: 'ready',        // 'idle' | 'initializing' | 'ready' | 'error' | 'destroyed'
  projectId: 'proj_...',
  locale: 'en-US',
  unreadCount: 3,         // number, or null before the first fetch;
                          // includes conversation replies, changelog posts,
                          // and feedback notifications
  presence: 'online',     // 'online' | 'neutral' — team availability (the green dot)
  lastError: null,        // the last error, or null
  widget: {
    enabled: true,
    open: false,
    position: 'right',      // 'left' | 'right'
    theme: 'auto'           // 'auto' | 'light' | 'dark'
  },
  session: {
    status: 'identified',   // 'anonymous' | 'identifying' | 'identified'
    identityTrust: 'signed',
    viewer: { id: 'mem_...', firstName: 'Ada', lastName: 'Lovelace', avatar: null }
  }
}
```

## uj.on(event, listener)

Subscribes to an event. Returns an unsubscribe function.

```javascript
const off = uj.on('unread', ({ count }) => updateBadge(count));
off();
```

| Event         | Payload                     | When it fires                                                 |
| ------------- | --------------------------- | ------------------------------------------------------------- |
| `ready`       | state                       | Loading settled. Fires immediately if already settled.        |
| `statechange` | state                       | Any state change.                                             |
| `open`        | state                       | Widget became visible.                                        |
| `close`       | state                       | Widget was hidden.                                            |
| `identify`    | `{ viewer, identityTrust }` | Identity changed, including logout.                           |
| `unread`      | `{ count }`                 | Unread count changed.                                         |
| `presence`    | `{ availability }`          | Team availability flipped between `'online'` and `'neutral'`. |
| `error`       | error                       | Any SDK error.                                                |
| `destroy`     | state                       | The SDK was destroyed.                                        |

Listeners survive `destroy()`, so you can subscribe once at page load even if
you destroy and re-init the SDK.

`presence` is the same signal as the green dot inside the widget. `'neutral'`
means the SDK cannot currently prove anyone from the team is online — it never
claims the team is offline, so treat it as "hide the dot", not "show offline".
Subscribing to `unread` or `presence` keeps both values fresh in the
background, even with the default launcher disabled.

## uj.destroy(options?)

Removes the widget, all embeds, and the session from the page.

```javascript
uj.destroy();
uj.destroy({ clearConversationData: true }); // also clear local conversation data
```

`clearConversationData` additionally clears the browser's local conversation
state: anonymous conversation access grants, drafts, and remembered contact
details. Use it on shared devices or kiosk-style setups where the next visitor
should not see the previous visitor's guest conversations.

After `destroy`, you can call `init` again to start fresh.

## Errors

Errors have the shape `{ code, message, recoverable, cause? }`. They reach you
through rejected promises for programmer errors, and through the `error` event
and `onError` callback for everything else.

| Code                        | Meaning                                                                                                                       |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `INVALID_PROJECT_ID`        | `init` was called with an empty project ID.                                                                                   |
| `INVALID_OPTIONS`           | `init` or `setLocale` received malformed options, or `setTheme` received a value other than `'auto'`, `'light'`, or `'dark'`. |
| `INVALID_NAVIGATION`        | `open` received an unknown or invalid target.                                                                                 |
| `INVALID_IDENTIFY`          | `identify` input is missing both `token` and `user.id`.                                                                       |
| `IDENTIFY_FAILED`           | The server rejected the identify call, for example an invalid token.                                                          |
| `BOOTSTRAP_FAILED`          | The SDK could not load. Check the project ID and network.                                                                     |
| `NOT_READY`                 | A call ran while the SDK was in a failed state.                                                                               |
| `WIDGET_DISABLED`           | `open` was called but the widget is disabled.                                                                                 |
| `CONVERSATIONS_DISABLED`    | Messages are disabled for this workspace. The widget opens home instead.                                                      |
| `LAUNCHER_NOT_FOUND`        | The `launcher.selector` element does not exist.                                                                               |
| `SIDEBAR_LOAD_FAILED`       | The widget UI failed to load.                                                                                                 |
| `EMBED_CONTAINER_NOT_FOUND` | The embed container does not exist.                                                                                           |
| `DESTROYED`                 | A call ran after `destroy()`.                                                                                                 |
| `UNKNOWN`                   | Anything else.                                                                                                                |

# Automatic login

Source: https://userjot.com/docs/automatic-login
Section: Authentication
Updated: 2026-10-06

> Sign your users in to UserJot automatically from your app, so the board, roadmap, and widget open with a trusted identity and no second login.

Automatic login lets UserJot recognize people who are already signed in to your
product when they open your public UserJot surfaces.

It is separate from the widget itself. The widget can identify users on its
own, but automatic login is what lets that identity carry over to your public
board, roadmap, or changelog without asking the user to sign in again.

## What automatic login does

After you identify the current user in the SDK, UserJot can attach a
`clientToken` to allowed UserJot links from your product. When the user follows
one of those links, UserJot reads that token and starts the public session as
the identified user.

In practice, the flow looks like this:

1. Enable automatic login in the UserJot dashboard.
2. Load the SDK in your product.
3. Call `window.uj.identify(...)` for the signed-in user.
4. Link users to your board, roadmap, or updates page from your product.

## Before you implement it

Enable the feature first in the dashboard:

1. Open **Settings** in your workspace.
2. Go to **Login**.
3. Under **Authentication**, turn on
   **Automatic login**.
4. If you want the stricter setup, also enable
   **Require signed tokens**. This option appears once
   automatic login is on.

Automatic login requires a paid plan. On the Free plan, the toggle is visible
but disabled.

If you want the product-side explanation of those settings, use the support
guide at [/support/automatic-login](https://userjot.com/support/automatic-login).

## Basic implementation

Load the SDK and initialize UserJot:

```html
<script>
  window.$ujq = window.$ujq || [];
  window.uj =
    window.uj ||
    new Proxy(
      {},
      {
        get:
          (_, p) =>
          (...a) =>
            window.$ujq.push([p, ...a])
      }
    );
  document.head.appendChild(
    Object.assign(document.createElement('script'), {
      src: 'https://cdn.userjot.com/sdk/v2/uj.js',
      type: 'module',
      async: !0
    })
  );
</script>
<script>
  window.uj.init('YOUR_PROJECT_ID');
</script>
```

Then identify the signed-in user from your product:

```html
<script>
  window.uj.identify({
    id: 'USER_UNIQUE_ID',
    email: 'user@example.com',
    firstName: 'John',
    lastName: 'Doe',
    avatar: 'https://example.com/avatar.jpg'
  });
</script>
```

The `id` field is required. `email` is strongly recommended because it helps
UserJot keep the public identity more useful and easier to reconcile.

## Secure mode: signed tokens

If **Require signed tokens** is enabled, include a
server-generated `signature` in the `identify()` payload.

```html
<script>
  window.uj.identify({
    id: 'USER_UNIQUE_ID',
    email: 'user@example.com',
    firstName: 'John',
    lastName: 'Doe',
    avatar: 'https://example.com/avatar.jpg',
    signature: 'SERVER_GENERATED_SIGNATURE'
  });
</script>
```

The signature must be generated on your server. Do not generate it in the
browser or expose your workspace secret to the client.

The current secure mode verifies an HMAC SHA-256 signature of the user ID
using your workspace secret. Copy the secret from the **Secrets** section on

**Settings** → **Login**,
where it is listed as **Project secret**.

### Server-side signing examples

```javascript title="Node.js"
import crypto from 'node:crypto';

export function signUserJotIdentity(userId, secret) {
  return crypto.createHmac('sha256', secret).update(userId).digest('hex');
}
```

```python title="Python"
import hmac
import hashlib

def sign_userjot_identity(user_id: str, secret: str) -> str:
    return hmac.new(
        secret.encode("utf-8"),
        user_id.encode("utf-8"),
        hashlib.sha256,
    ).hexdigest()
```

```php title="PHP"
<?php

function signUserJotIdentity(string $userId, string $secret): string
{
    return hash_hmac('sha256', $userId, $secret);
}
```

```ruby title="Ruby"
require 'openssl'

def sign_userjot_identity(user_id, secret)
  OpenSSL::HMAC.hexdigest('sha256', secret, user_id)
end
```

```csharp title="C#"
using System.Security.Cryptography;
using System.Text;

public static string SignUserJotIdentity(string userId, string secret)
{
    var secretBytes = Encoding.UTF8.GetBytes(secret);
    var userIdBytes = Encoding.UTF8.GetBytes(userId);

    using var hmac = new HMACSHA256(secretBytes);
    var hash = hmac.ComputeHash(userIdBytes);
    return Convert.ToHexString(hash).ToLowerInvariant();
}
```

Use the returned value as `signature` in `window.uj.identify(...)`.

## What happens after `identify()`

Once the SDK knows who the user is, UserJot can add authentication data to
supported UserJot links from your product.

For example, links like these can carry the identified session through:

```html
<a href="https://feedback.example.com/">Give feedback</a>
<a href="https://feedback.example.com/roadmap">Roadmap</a>
<a href="https://feedback.example.com/updates">Updates</a>
```

You do not need to manually build the `clientToken` yourself. The SDK handles
that after identification, as long as the target URL points to an allowed
UserJot domain for the current project.

## Important limitations

- Automatic login does not work for admin or owner accounts. Test with a normal
  end-user account.
- Automatic login applies to public UserJot surfaces. It is not the same thing
  as workspace SSO.
- Secure mode is enforced server-side. If signed tokens are required and the
  signature is missing or invalid, the automatic login flow will fail.

## Common implementation pattern

In most apps, you should call `identify()` after the user session is ready and
call `identify(null)` when the user logs out.

```javascript
if (user) {
  window.uj.identify({
    id: user.id,
    email: user.email,
    firstName: user.firstName,
    lastName: user.lastName,
    signature: user.userJotSignature
  });
} else {
  window.uj.identify(null);
}
```

## Troubleshooting

### The user still sees a login prompt

Check these first:

- Automatic login is enabled in the workspace settings
- The SDK is loaded on the page where the UserJot link lives
- `identify()` runs before the user opens the link
- The URL points to your actual UserJot domain or custom domain

### Secure mode is enabled, but automatic login still fails

Check these:

- The `signature` field is included
- The signature was generated on the server
- The signature was generated from the correct user ID
- The workspace secret used for signing matches the current workspace

# Single sign-on

Source: https://userjot.com/docs/single-sign-on
Section: Authentication
Updated: 2026-10-06

> Implement single sign-on for your public UserJot board: your server signs a JWT with the user's identity, and UserJot accepts it as the login.

Single sign-on lets users sign in to your public UserJot board through your own
authentication system. When users click **Sign In**,
UserJot sends them to your SSO endpoint. After you authenticate them, you send
them back to UserJot with a signed JWT.

This is for public board login. It is separate from
[automatic login](https://userjot.com/docs/automatic-login), which carries widget-identified users
into public UserJot surfaces from your app.

## Enable SSO

1. Open **Settings** in your workspace.
2. Go to **Login**.
3. Under **Authentication**, set **Board login** to
   **SSO**. The first time you do this, an **Enable
   SSO** dialog asks for your redirect URL.
4. Enter your SSO redirect URL and confirm with
   **Enable SSO**. You can change it later from the
   **SSO redirect URL** section on the same page.
5. Copy your **Project ID** and
   **Project secret** from the **Secrets** section.

Your SSO redirect URL must use `https://`. During local development, use an
HTTPS tunnel if you need to test the full redirect flow.

Board login modes require the Professional plan.

## How the flow works

When a user starts SSO, UserJot redirects their browser to your configured SSO
Redirect URL. The only query parameter your endpoint needs is `state`:

```txt
https://yourapp.com/userjot/sso?state=OPAQUE_STATE_FROM_USERJOT
```

Your endpoint should:

1. Read the `state` query parameter.
2. Authenticate the user in your app.
3. Create a JWT signed with your UserJot Project secret.
4. Redirect to `https://api.userjot.com/auth/sso` with `jwt` and the original
   `state`.

Do not modify the `state` value. UserJot uses it to verify that the login was
started by the same browser session. The state value is one-time use and expires
after 15 minutes.

If the user is not signed in yet, send them through your normal login flow and
then return them to this same SSO endpoint with the original query parameters.

## JWT payload

The JWT must be signed with `HS256` using your UserJot Project secret.

At minimum, send the user ID, issuer, audience, and expiration. You can also
include an email address, profile fields, custom traits, and company
memberships.

| Claim       | Required | Description                     |
| ----------- | -------- | ------------------------------- |
| `sub`       | Yes      | Stable user ID from your system |
| `email`     | No       | User's email address            |
| `iss`       | Yes      | Exact UserJot Project ID        |
| `aud`       | Yes      | Exact string `userjot`          |
| `exp`       | Yes      | Unix expiration timestamp       |
| `iat`       | No       | Unix issued-at timestamp        |
| `firstName` | No       | Given profile field             |
| `lastName`  | No       | Family profile field            |
| `avatar`    | No       | Avatar URL                      |
| `traits`    | No       | Custom user traits              |
| `companies` | No       | Company or account memberships  |

Example payload:

```javascript
const now = Math.floor(Date.now() / 1000);

const payload = {
  sub: 'user_123',
  email: 'jane@example.com',
  firstName: 'Jane',
  lastName: 'Doe',
  iss: 'YOUR_PROJECT_ID',
  aud: 'userjot',
  iat: now,
  exp: now + 10 * 60
};
```

Use a short expiration window. Five to fifteen minutes is a good default. If you
include `iat`, it must not be in the future beyond normal clock skew.

If `email` is omitted, UserJot identifies the user by `sub` and creates or
updates a member without an email address. Email-based linking and email
notifications only become available after an email address is provided.

Trait values must be JSON scalars: strings, numbers, booleans, or `null`.
Nested objects and arrays are ignored.

## Example endpoint

```javascript title="Hono"
import { Hono } from 'hono';
import jwt from 'jsonwebtoken';

const app = new Hono();

const USERJOT_PROJECT_ID = 'YOUR_PROJECT_ID';
const USERJOT_PROJECT_SECRET = 'YOUR_PROJECT_SECRET';
const USERJOT_CALLBACK_URL = 'https://api.userjot.com/auth/sso';

app.get('/userjot/sso', async (c) => {
  const state = c.req.query('state');

  if (!state) {
    return c.text('Missing state', 400);
  }

  // Authenticate the user however your app normally does.
  const user = await getCurrentUser(c);

  const payload = {
    sub: user.id,
    email: user.email,
    firstName: user.firstName,
    lastName: user.lastName,
    iss: USERJOT_PROJECT_ID,
    aud: 'userjot'
  };

  const token = jwt.sign(payload, USERJOT_PROJECT_SECRET, {
    algorithm: 'HS256',
    expiresIn: '10m'
  });

  const callback = new URL(USERJOT_CALLBACK_URL);
  callback.searchParams.set('jwt', token);
  callback.searchParams.set('state', state);

  return c.redirect(callback.toString());
});
```

Keep the Project secret on your server. Never expose it in browser code.

## Company data

If your product is account-based, you can include company memberships in the
same JWT payload:

```json
{
  "companies": [
    {
      "id": "company_456",
      "domain": "acme.com",
      "logo": "https://example.com/acme.png",
      "traits": {
        "plan": "enterprise",
        "seats": 42
      }
    }
  ]
}
```

Use `id` for the stable account ID from your system. You can skip company data
unless it is useful for your workspace.

## Troubleshooting

### Users are sent back without being logged in

Check that:

- the JWT is signed with the current Project secret
- `iss` matches the exact Project ID from your workspace settings
- `aud` is the exact string `userjot`
- `sub` and `exp` are present
- your endpoint sends back the exact `state` value it received

If SSO fails after the callback, UserJot redirects back to the board with an
`sso_error` query parameter such as `invalid_state`, `invalid_token`,
`auth_failed`, or `session_error`.

### The login button does not use SSO

Check that **Board login** is set to

**SSO** in **Settings** →
**Login**.

### You changed the Project secret

After rotating the Project secret, update your SSO endpoint immediately. Tokens
signed with the old secret will no longer work.

# Overview

Source: https://userjot.com/docs/sdk-swift-overview
Section: Integrations / Swift
Updated: 2026-10-06

> What the UserJot Swift SDK covers for native iOS apps, how it relates to the web widget, and where to start depending on what you want to add first.

The UserJot Swift SDK lets you bring feedback collection and roadmap
visibility directly into your iOS or macOS app.

At a high level, the SDK gives you two things:

- native presentation helpers for feedback and roadmap
- user identification so UserJot activity can stay tied to the right user

## What the Swift SDK is for

Use the Swift SDK when you want UserJot to feel like part of your app rather
than a separate website.

Common uses:

- add a native feedback entry point inside your app
- show the roadmap from app settings or help screens
- identify signed-in users before they send feedback
- keep presentation logic simple in SwiftUI or UIKit

## What it includes

The current Swift SDK supports:

- project setup with `UserJot.setup(projectId:)`
- user identification with `UserJot.identify(...)`
- feedback presentation with `UserJot.showFeedback()`
- roadmap presentation with `UserJot.showRoadmap()`
- a SwiftUI `.userJotFeedback(...)` modifier
- custom URLs if you want to handle presentation yourself

`showChangelog()` exists in 0.3.0, but it opens `/changelog`. The public route
is `/updates`, with no redirect, so that call does not work in this release.

## Platforms and requirements

The SDK currently targets:

- iOS 15.0+
- macOS 12.0+
- Swift 6.1+
- Xcode 16.3+

The current public package is still in beta, so you should expect some API
evolution before a 1.0 release.

## Recommended integration path

For most teams, the cleanest path is:

1. Install the package with Swift Package Manager.
2. Call `UserJot.setup(projectId:)` once during app startup.
3. Identify the current user when your app session becomes available.
4. Present feedback or the roadmap from the parts of the app where they make
   sense.

## How to think about the SDK

Use the built-in presentation methods if you want the fastest path to an
in-app UserJot experience.

Use the custom URL methods if you want to present the experience in your own
WebView or app container.

# Installation

Source: https://userjot.com/docs/sdk-swift-installation
Section: Integrations / Swift
Updated: 2026-10-06

> Add the UserJot Swift SDK to an iOS app with Swift Package Manager, initialize it with your project id, and confirm the first screen opens.

Install the Swift SDK with Swift Package Manager, then initialize it with your
UserJot project ID during app startup.

## Requirements

Before installing, make sure your app meets these minimum requirements:

- iOS 15.0+ or macOS 12.0+
- Swift 6.1+
- Xcode 16.3+

## Install with Swift Package Manager

### In Xcode

1. Open your project in Xcode.
2. Go to **File** →
   **Add Package Dependencies**.
3. Enter this package URL:

```text
https://github.com/UserJot/userjot-ios
```

4. Add the package to your app target.

### In Package.swift

If you manage dependencies in `Package.swift`, add UserJot to your package
dependencies:

```swift
dependencies: [
    .package(url: "https://github.com/UserJot/userjot-ios", from: "0.3.0")
]
```

## Verify the package is available

After installation, confirm the SDK imports correctly:

```swift
import UserJot
```

If the project builds, the package is installed correctly.

## Find your project ID

You need your UserJot project ID before calling `setup(...)`.

In your UserJot dashboard, open **Settings** →

**Login** and copy
**Project ID** from the **Secrets** section. Keep it
available to your app startup code.

## Initialize the SDK

Call `UserJot.setup(projectId:)` once when the app starts:

```swift
import UserJot

UserJot.setup(projectId: "YOUR_PROJECT_ID")
```

### SwiftUI example

```swift
import SwiftUI
import UserJot

@main
struct MyApp: App {
    init() {
        UserJot.setup(projectId: "YOUR_PROJECT_ID")
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
```

### UIKit example

```swift
import UIKit
import UserJot

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
    ) -> Bool {
        UserJot.setup(projectId: "YOUR_PROJECT_ID")
        return true
    }
}
```

## Verify the integration

`setup` returns immediately and fetches the public URL in the background. There
is no async result and no readiness callback. Calling `showFeedback()` on the
same tick as `setup` can show nothing, because that URL is still nil.

Present from a later user action instead:

```swift
Button("Send Feedback") {
    UserJot.showFeedback()
}
```

If the view opens, the SDK is installed and initialized. `UserJot.feedbackURL()`
stays `nil` until the background fetch finishes.

## macOS note

For sandboxed macOS apps, enable outbound network access in your entitlements:

```xml
<key>com.apple.security.network.client</key>
<true/>
```

Without that entitlement, the SDK will not be able to load remote content.

# Authentication

Source: https://userjot.com/docs/sdk-swift-authentication
Section: Integrations / Swift
Updated: 2026-10-06

> Authenticate app users in the UserJot Swift SDK: pass identity from your sign-in flow, sign it on your server, and handle anonymous and signed-in states.

Use `UserJot.identify(...)` to tell UserJot who the current app user is.

Once a user is identified, feedback activity can stay tied to the right person,
and UserJot can provide a more consistent signed-in experience across the SDK
surfaces.

## Basic identification

The minimum identification call only needs your own stable user ID:

```swift
UserJot.identify(userId: "user_123")
```

Use the user ID from your own system. It should be stable for that user over
time, not a session ID and not a temporary token.

## Add email and profile fields

In most apps, you should include email as well:

```swift
UserJot.identify(
    userId: "user_123",
    email: "john@example.com"
)
```

If you already have more profile data, you can include it too:

```swift
UserJot.identify(
    userId: "user_123",
    email: "john@example.com",
    firstName: "John",
    lastName: "Doe",
    avatar: "https://example.com/avatar.jpg"
)
```

## When to identify

The normal pattern is:

- call `identify(...)` after the app restores or creates an authenticated session
- call it again if important profile fields change
- clear the identity when the user logs out

For example:

```swift
func handleLogin(user: User) {
    UserJot.identify(
        userId: user.id,
        email: user.email,
        firstName: user.firstName,
        lastName: user.lastName
    )
}
```

## Logging out

Clear the current UserJot identity when the user logs out:

```swift
UserJot.logout()
```

## Signed authentication

If you want a stricter trust model, generate a server-side signature and pass it
with the identification payload. The signature is an HMAC-SHA256 hash of the
user ID, keyed with your **Project secret**. Copy the
secret from the **Secrets** section on **Settings** →

**Login** in your UserJot dashboard.

To require signatures for every identification, turn on

**Automatic login** on that same page, then enable
**Require signed tokens**, which appears once automatic
login is on.

```swift
UserJot.identify(
    userId: "user_123",
    email: "john@example.com",
    signature: signatureFromYourServer
)
```

The signature should be generated on your server, not in the app.

### Server-side signing examples

```javascript title="Node.js"
import crypto from 'node:crypto';

export function signUserJotIdentity(userId, secret) {
  return crypto.createHmac('sha256', secret).update(userId).digest('hex');
}
```

```python title="Python"
import hmac
import hashlib

def sign_userjot_identity(user_id: str, secret: str) -> str:
    return hmac.new(
        secret.encode("utf-8"),
        user_id.encode("utf-8"),
        hashlib.sha256,
    ).hexdigest()
```

```php title="PHP"
<?php

function signUserJotIdentity(string $userId, string $secret): string
{
    return hash_hmac('sha256', $userId, $secret);
}
```

```ruby title="Ruby"
require 'openssl'

def sign_userjot_identity(user_id, secret)
  OpenSSL::HMAC.hexdigest('sha256', secret, user_id)
end
```

Use the returned value as the `signature` argument in `UserJot.identify(...)`.

## SwiftUI app pattern

In a SwiftUI app, identification usually happens once your auth state is ready:

```swift
@main
struct MyApp: App {
    @StateObject private var authManager = AuthManager()

    init() {
        UserJot.setup(projectId: "YOUR_PROJECT_ID")
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
                .onAppear {
                    if let user = authManager.currentUser {
                        UserJot.identify(
                            userId: user.id,
                            email: user.email
                        )
                    }
                }
        }
    }
}
```

## Practical guidance

- identify the user as early as you safely can after authentication
- use stable IDs from your own system
- include email when you have it
- clear the identity on logout
- keep signing logic on the server

# Common flows

Source: https://userjot.com/docs/sdk-swift-common-flows
Section: Integrations / Swift
Updated: 2026-10-06

> The UserJot actions most iOS apps need, in Swift: open the feedback board, submit a request, show the roadmap and changelog, and start a chat.

Once the SDK is set up, the most common work is presenting feedback and the
roadmap from the right places in your app.

## Show feedback

Use `showFeedback()` to open the default feedback experience:

```swift
UserJot.showFeedback()
```

Do not pass `board:` in 0.3.0. That helper builds `/boards/{slug}`, and the
live route is `/board/{slug}`.

## Show roadmap

```swift
UserJot.showRoadmap()
```

## Show changelog

`showChangelog()` exists, but in 0.3.0 it opens `/changelog`. The public route
is `/updates`, with no redirect, so this call does not work yet.

## Presentation styles on iOS

On iOS, UserJot surfaces are presented as native sheets.

The SDK currently supports multiple presentation styles:

```swift
UserJot.showFeedback()                                // default
UserJot.showFeedback(presentationStyle: .sheet)       // full-height sheet
UserJot.showFeedback(presentationStyle: .mediumSheet) // medium sheet on supported versions
```

Choose the style that fits the surrounding app flow. For example, a medium
sheet can work well for lightweight feedback entry, while the full-height sheet
gives the content more room.

## SwiftUI flow

For SwiftUI apps, the cleanest pattern is usually a state-driven modifier:

```swift
import SwiftUI
import UserJot

struct ContentView: View {
    @State private var showingFeedback = false

    var body: some View {
        Button("Send Feedback") {
            showingFeedback = true
        }
        .userJotFeedback(isPresented: $showingFeedback)
    }
}
```

Roadmap has no SwiftUI modifier in 0.3.0. Call `showRoadmap()` from a button
action instead.

## Common product pattern

A typical settings or help screen might expose both:

```swift
struct SettingsView: View {
    @State private var showingFeedback = false

    var body: some View {
        List {
            Button("Send Feedback") {
                showingFeedback = true
            }

            Button("View Roadmap") {
                UserJot.showRoadmap()
            }
        }
        .userJotFeedback(isPresented: $showingFeedback)
    }
}
```

## Use your own presentation container

If you do not want the SDK to control presentation, you can ask it for the
underlying URLs and load them in your own WebView or app container:

```swift
let feedbackURL = UserJot.feedbackURL()
let roadmapURL = UserJot.roadmapURL()
```

`changelogURL()` has the same `/changelog` path issue as `showChangelog()`.

That is the better fit when:

- your app already has a custom WebView shell
- you need tighter control over navigation or chrome
- you want UserJot inside an existing in-app presentation system

## Choosing the right approach

- Use `showFeedback` and `showRoadmap` for the fastest path.
- Use `.userJotFeedback` when feedback presentation should be state-driven.
- Use the URL methods when you need full control over presentation.

# Overview

Source: https://userjot.com/docs/mcp-overview
Section: Integrations / MCP
Updated: 2026-10-06

> What the UserJot MCP server is, which tools it exposes for feedback, roadmap, changelog, and conversations, how it authenticates, and what connects.

The UserJot MCP integration lets AI tools connect directly to your UserJot
workspace through a remote MCP server.

If your editor or assistant supports remote MCP servers, you can connect it to
UserJot without installing a local package or running your own bridge process.

## Server URL

UserJot exposes a single remote MCP endpoint:

```text
https://api.userjot.com/v1/mcp
```

This is a remote HTTP MCP server, so your client needs to support remote MCP
connections and custom headers.

## Authentication

Authenticate requests with a UserJot API token:

```text
Authorization: Bearer YOUR_USERJOT_API_TOKEN
```

Create the token in your UserJot dashboard under `Settings` →
`API Tokens`.

## When to use MCP

Use the MCP server when you want an AI assistant to work with UserJot directly
from a supported client like Claude Code, Cursor, or Windsurf.

MCP is a good fit when you want to:

- pull UserJot context into an AI workflow
- let an assistant inspect workspace data without building a custom integration
- connect UserJot to an MCP-aware coding or research tool

## MCP vs REST API

Use MCP when the integration target is an AI client that already understands
the Model Context Protocol.

Use the UserJot REST API when you are building your own backend integration,
automation, or application code and want full control over requests and
responses.

## What you need

Before setting up a client, make sure you have:

- a UserJot workspace with API access enabled
- a UserJot API token from `Settings` → `API Tokens`
- an MCP-compatible client that supports remote HTTP servers

## Token handling

Treat your UserJot API token like any other secret:

- do not hardcode it into committed config files
- prefer environment variables or a local secrets manager when your client
  supports them
- use separate tokens for different environments or teammates when possible
- revoke tokens you no longer need from the UserJot dashboard

# Common setup

Source: https://userjot.com/docs/mcp-common-setup
Section: Integrations / MCP
Updated: 2026-08-25

> Prepare your UserJot token and remote MCP settings before connecting a client.

UserJot does not require a local MCP package. You connect your client directly
to the remote UserJot MCP server using the server URL and an API token.

## What you will need

You need two values:

```text
Server URL: https://api.userjot.com/v1/mcp
Authorization: Bearer YOUR_USERJOT_API_TOKEN
```

Create the token in UserJot under `Settings` → `API Tokens`.

## Generic remote MCP shape

Most MCP clients that support remote HTTP servers use a configuration that
looks roughly like this:

```json
{
  "mcpServers": {
    "userjot": {
      "url": "https://api.userjot.com/v1/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_USERJOT_API_TOKEN"
      }
    }
  }
}
```

The exact file path and field names vary by client, which is why the rest of
this section has separate setup pages for Claude Code, Cursor, Codex,
ChatGPT, and Windsurf.

## Verify the connection

After setup, open your MCP-aware client and ask it to inspect the connected
UserJot server or list available tools.

If the connection is working, the client should discover the UserJot MCP server
without additional local setup.

## Troubleshooting

If the connection fails, check these first:

- the token is valid and has not been revoked
- the `Authorization` header starts with `Bearer `
- your client supports remote HTTP MCP servers
- your config file is in the correct location for that client
- you restarted the client after editing the config

## Notes on other MCP clients

Remote MCP support is still moving quickly across clients.

If your preferred tool is not listed here, use the same server URL and bearer
token, then adapt them to that client's remote MCP configuration format.

# Claude Code

Source: https://userjot.com/docs/mcp-claude-code
Section: Integrations / MCP
Updated: 2026-10-06

> Add the UserJot MCP server to Claude Code as a remote HTTP server with one command, then answer conversations, file feedback, and update the roadmap.

Claude Code has first-class support for remote HTTP MCP servers, which makes it
one of the simplest ways to connect UserJot over MCP.

## What you need

Before you start, make sure you have:

- the UserJot MCP endpoint: `https://api.userjot.com/v1/mcp`
- a UserJot API token from `Settings` → `API Tokens`

## Add the server

Run:

```bash
claude mcp add --transport http userjot https://api.userjot.com/v1/mcp \
  --header "Authorization: Bearer YOUR_USERJOT_API_TOKEN"
```

Claude Code stores the server in its MCP configuration and makes it available
to the current scope.

## Verify the connection

Check that the server was added:

```bash
claude mcp list
```

You can also inspect MCP status from inside Claude Code with:

```text
/mcp
```

## Notes

- Anthropic currently recommends HTTP for remote MCP servers when available.
- If you want the server available in every project, use Claude Code's user
  scope instead of the default local scope.
- Keep your token out of version-controlled config files unless you have a safe
  secret-management flow in place.

# Cursor

Source: https://userjot.com/docs/mcp-cursor
Section: Integrations / MCP
Updated: 2026-10-06

> Configure the UserJot MCP server in Cursor as a remote server, authenticate with an API token, and work your feedback board and inbox from the editor.

Cursor supports remote MCP servers through `mcp.json`.

## Choose a config location

Use one of these locations:

- `~/.cursor/mcp.json` for a global setup
- `.cursor/mcp.json` in a project for a project-specific setup

## Add the UserJot server

Add this configuration:

```json
{
  "mcpServers": {
    "userjot": {
      "url": "https://api.userjot.com/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${env:USERJOT_API_TOKEN}"
      }
    }
  }
}
```

## Set your token

Set `USERJOT_API_TOKEN` in your shell or environment before launching Cursor.

Using an environment variable is better than hardcoding the token directly into
`mcp.json`.

## Restart and verify

Restart Cursor after updating the config, then open an agent chat and confirm
the `userjot` MCP server appears in the available tools list.

If the server does not appear, check:

- the JSON is valid
- the file is in the correct location
- the environment variable is available to Cursor
- the token has not been revoked

# Codex

Source: https://userjot.com/docs/mcp-codex
Section: Integrations / MCP
Updated: 2026-10-06

> Connect the UserJot MCP server to Codex so your agent can answer conversations, file and vote on feedback, and move the roadmap from the terminal.

OpenAI documents MCP support for Codex, with configuration shared between the
CLI and IDE extension.

## Use these UserJot values

When Codex asks for the remote MCP server details, use:

```text
Name: userjot
URL: https://api.userjot.com/v1/mcp
Authorization: Bearer YOUR_USERJOT_API_TOKEN
```

## Important note

Codex MCP support is still evolving quickly, and the exact remote-server setup
flow may differ between Codex releases.

Because of that, the most reliable approach is:

1. Follow Codex's current MCP setup flow in the CLI or IDE extension.
2. Use the UserJot endpoint above as the server URL.
3. Provide your UserJot API token as a bearer token when Codex asks for
   headers or authentication details.

## Shared configuration

OpenAI's docs indicate that Codex shares MCP configuration between the CLI and
the IDE extension, so you should only need to configure the UserJot server once
per environment.

## If your Codex build behaves differently

If your installed Codex version does not yet expose the same remote MCP setup
flow as the current OpenAI docs, use the values above with the latest official
Codex MCP instructions for your version.

# ChatGPT

Source: https://userjot.com/docs/mcp-chatgpt
Section: Integrations / MCP
Updated: 2026-10-06

> Add the UserJot MCP server to ChatGPT as a custom remote app, authenticate with an API token, and let ChatGPT answer conversations and file feedback.

ChatGPT desktop connects to UserJot over MCP. You add the remote server in
the desktop app, not by editing a local editor config.

ChatGPT on the web works differently. It uses MCP-backed tools from installed
plugins and does not take a custom server URL or bearer token in settings.

## Use these UserJot values

When ChatGPT asks for your MCP server details, use:

```text
Endpoint: https://api.userjot.com/v1/mcp
Authorization: Bearer YOUR_USERJOT_API_TOKEN
```

Create the token in UserJot under `Settings` → `API Tokens`.

## Add the server in ChatGPT desktop

1. Open `Settings`, then select `MCP servers`.
2. Select `Add server`.
3. Enter a name such as `userjot`.
4. Choose `Streamable HTTP` and paste the UserJot endpoint.
5. Provide bearer-token authentication using your UserJot API token.
6. Save the server, then select `Restart`.

Type `/mcp` in the composer to confirm the server is connected.

If the Add server form has no auth field, set the same URL in
`~/.codex/config.toml` with `bearer_token_env_var` pointing at an environment
variable that holds your token. ChatGPT desktop shares that config with Codex.

## ChatGPT web

On the web, ChatGPT does not accept a local or remote MCP server
configuration. MCP-backed tools come from plugins you install, not from
pasting `https://api.userjot.com/v1/mcp` into settings.

Use ChatGPT desktop when you want UserJot with your own API token.

## Notes

- Workspace admins may restrict MCP servers or plugins.
- Availability can still vary by plan and workspace settings.
- Keep your token out of anything you would commit or share.

# Windsurf

Source: https://userjot.com/docs/mcp-windsurf
Section: Integrations / MCP
Updated: 2026-10-06

> Configure the UserJot MCP server in Windsurf as a remote server with an API token, then answer conversations and manage feedback from your agent.

Windsurf supports remote MCP servers through its MCP config file.

## Open the MCP config

Edit:

```text
~/.codeium/windsurf/mcp_config.json
```

## Add the UserJot server

Add this configuration:

```json
{
  "mcpServers": {
    "userjot": {
      "serverUrl": "https://api.userjot.com/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${env:USERJOT_API_TOKEN}"
      }
    }
  }
}
```

Windsurf supports variable interpolation in MCP config values, which makes
environment variables the safest place to store your token.

## Set your token

Set `USERJOT_API_TOKEN` in your environment before starting Windsurf.

## Restart and verify

Restart Windsurf after updating the config, then open the MCP panel and confirm
the `userjot` server is available.

If it does not connect, check:

- the JSON is valid
- the token environment variable is set
- the token is still active in UserJot
- the config file is in the expected Windsurf path

# Invite your team

Source: https://userjot.com/support/invite-your-team
Section: Workspace Setup
Updated: 2026-09-16

> Add teammates to your workspace so feedback triage stays collaborative.

UserJot is easier to manage with more than one person involved. Invite
teammates when you want help reviewing feedback, replying to users, planning
work, and publishing updates.

## Invite a teammate

1. Open **Settings** in your workspace, then go to

   **Team**.

2. On the **Members** card, select **Invite member**.

3. Enter your teammate's email address and select

   **Invite**.

4. After the invite is sent, an **Invitations** section appears below the
   members list so you can track pending invites from one place.

5. Once the person joins, they appear in the **Members** section with the rest
   of your workspace team.

## What you can manage from the Team page

The **Members** section lists your internal team: workspace owners and admins.
Regular users who participate on your public board are not shown here. You can
review the current team, see each person's role, and open the member menu for
additional actions.

The **Invitations** section shows pending invites that have not been accepted
yet, and it is only visible while at least one invite is pending. If you sent
an invite by mistake or no longer need it, open the invite's row menu and
select **Revoke invite**.

## A few things to keep in mind

Invited teammates join as admins, so this page is best used for internal
collaborators rather than end users.

If needed, you can update a teammate's title later from the member menu. This
is useful for labels like Founder, Product Manager, or Support Lead.

Your current plan may limit how many team members you can add. If you reach
that limit, UserJot will prompt you to upgrade before sending more invites.

# Share your board

Source: https://userjot.com/support/share-your-board
Section: Workspace Setup
Updated: 2026-08-27

> Publish your board and start collecting customer feedback from one link.

Once your board is ready, the next step is simple: put the link somewhere your
users will actually see it. UserJot gives you one main public link for your
feedback board, and you can optionally share separate links for your roadmap
and changelog.

## Share your board

1. Open your workspace dashboard and go to **Share** in
   the sidebar.

2. At the top of the page, your board's live URL is shown with two buttons.
   Copy your main public link with **Copy link** or
   open it with **Visit** to check how it looks first.

3. Add that link anywhere users already expect to find product updates or a way
   to contact your team. Good places include your website navigation, footer,
   help center, onboarding emails, support replies, and in-app menus.

4. If you want to link to your roadmap or changelog separately, scroll to the
   **Add to your app or website** section. It lists your **Feedback**,
   **Roadmap**, and **Changelog** links, and
   **Copy all links** copies all three at once.

## Common link patterns

If you use your default UserJot subdomain, the public URLs usually look like
this:

```html
<a href="https://yourproject.userjot.com/">Share feedback</a>
<a href="https://yourproject.userjot.com/roadmap">See what's coming</a>
<a href="https://yourproject.userjot.com/updates">Latest updates</a>
```

If you use a custom domain, the same pattern applies on that domain:

```html
<a href="https://feedback.yourcompany.com/">Give feedback</a>
<a href="https://feedback.yourcompany.com/roadmap">Product roadmap</a>
<a href="https://feedback.yourcompany.com/updates">What's new</a>
```

## Open the feedback form directly

If you want a link to open the feedback form immediately, add the
`?openFeedback` query parameter to the feedback URL:

```html
<a href="https://feedback.yourcompany.com/?openFeedback">Submit feedback</a>
```

That is useful for onboarding emails, support replies, and in-app calls to
action where you want to reduce one more click before submission.

For the implementation details, use the docs guide at
[/docs/deep-link-feedback](https://userjot.com/docs/deep-link-feedback).

If your product already loads the widget SDK, you can also redirect users to
the public feedback page programmatically:

```javascript
window.uj.redirect({ openFeedback: true });
```

For the full SDK method reference, use
[/docs/widget-sdk-reference](https://userjot.com/docs/widget-sdk-reference).

## What to check before you share it

Make sure the board name is clear, the board visibility matches what you want,
and the page feels ready for users to land on. If guest feedback is enabled,
people can submit with less friction. If it is not, users may need to sign in
first depending on your setup.

It is also worth opening the board once before you share it widely. That quick
check helps you catch simple issues like unclear wording, missing branding, or
an empty page that does not yet explain what kind of feedback you want.

## Good ways to present the link

Keep the label simple and specific. In most cases, plain language works better
than something clever. Good options include **Share feedback**, **Request a
feature**, **Report a bug**, or **Tell us what to build next**.

If you are sharing more than one link, use the main feedback board as the
default destination and reserve direct roadmap or changelog links for places
where users specifically want to see plans or recent updates.

## What users will see

The main board link gives users one place to submit feedback, browse existing
requests, and follow what is being discussed. Depending on how your workspace
is set up, they may also be able to vote, comment, and see product status
changes in the same public experience.

# Custom Domain

Source: https://userjot.com/support/custom-domain
Section: Workspace Setup
Updated: 2026-09-16

> Serve your feedback portal from a branded domain that matches your product.

Using a custom domain gives your public UserJot pages a branded home. Instead
of sending users to a `userjot.com` address, you can serve your workspace from
your own domain, such as `feedback.example.com`.

Custom domains are available on the Starter and Professional plans. On the
Free plan, **Add domain** opens an upgrade prompt
instead of the domain form.

## Add a custom domain

1. Open **Settings** in your workspace, then go to

   **Domain**.

2. Select **Add domain**.

3. Enter your root domain, such as `example.com`, then select

   **Save**.

4. After the domain is added, UserJot shows the DNS records you need to create.
   Add each record exactly as shown in your DNS provider.

5. Wait for the DNS records to propagate. UserJot checks those records from the
   **Domain** page and updates their status once they are active.

6. When the setup is complete, open your new domain with
   **Visit** to confirm it loads correctly.

## What domain to enter

Enter only the root domain that you own, such as `example.com`. UserJot uses
that to create your branded feedback address on the `feedback` subdomain, such
as `feedback.example.com`.

If you are not sure what to type, use the part of the domain you manage in your
DNS provider, not the full `https://` URL and not the `feedback.` prefix.

## Updating your DNS records

The **DNS records** table shows the exact records UserJot expects. For each
record, copy the **Name** and **Value** into your DNS provider exactly as
shown.

Many DNS providers automatically append your root domain for you, so the name
field may look shorter in UserJot than it does in your provider's interface.
If your provider supports it, UserJot may also show a direct link to your DNS
settings to make the update faster.

## How to know it is working

The **Domain** page keeps showing the DNS record statuses until everything is
ready. If the records are still pending, the most common cause is that the DNS
change has not propagated yet or one of the values does not match exactly.

Once the records are active, your public workspace should load on the new
domain. At that point, you can start sharing the branded link instead of the
default UserJot URL.

# Customize branding

Source: https://userjot.com/support/customize-branding
Section: Workspace Setup
Updated: 2026-10-06

> Add your product name, logo, colors, and brand assets to your public board, roadmap, and changelog so they match the rest of your product.

Branding helps your public UserJot pages feel like part of your product instead
of a separate tool. You can update the name, logo, colors, and other
public-facing settings from one place.

## Customize branding

1. Open **Settings** in your workspace, then go to

   **Branding**.

2. Update the settings you want to change. The page is split into three
   sections: **Brand** holds your logo and workspace name, **Appearance**
   holds **Primary color** and

   **Theme**, and **Public board** holds
   **Language** and the attribution toggle.

3. If you want to upload a new logo, select the current logo in the **Brand**
   section and choose your image file. UserJot supports common image formats,
   including PNG, JPG, and SVG.

4. If your plan supports it, turn on

   **Hide "Powered by"** in the **Public board**
   section to remove UserJot attribution from your
   public pages.

5. Select **Save** under the **Brand** section to
   apply logo and name changes. Everything else on the page, including color,
   theme, language, and attribution, saves immediately when you change it.

## Keep it simple

Keep the branding simple and recognizable. In most cases, using your product
name, your main logo, and one brand color is enough.

It is also worth checking how your choices look together before you finish. A
logo that looks good in one context may feel too small or too busy on a public
feedback page.

## Plan limits

Most branding controls are available on every plan. The exception is

**Hide "Powered by"**, which requires the Professional
plan.

# Localization

Source: https://userjot.com/support/fixed-language
Section: Workspace Setup
Updated: 2026-10-06

> Choose whether public pages auto-detect each visitor's language or stay locked to one locale, and see which languages UserJot translates into.

UserJot supports multiple languages across public boards, roadmap pages, and
changelogs, and that list continues to grow. By default, public pages use

**Auto-detect**, which means UserJot tries to match the
visitor's browser language.

When your workspace is set to **Auto-detect**,
signed-in users can also change the language themselves from their account menu
on the public page. That is usually the best option when your audience is
spread across multiple countries or languages.

## Set a fixed language

1. Open **Settings** in your workspace, then go to

   **Branding**.

2. Under **Public board**, find the **Language**
   setting.

3. Leave it on **Auto-detect** if you want UserJot to
   choose the language automatically for each visitor.

4. Select a specific language if you want all public pages in your workspace to
   stay in the same language for every visitor. The change applies immediately,
   so there is no separate save step.

## When to use auto-detect

Use **Auto-detect** when your audience is international
or when you want users to choose the language that feels best for them. This
keeps the public experience more flexible and lets the language menu stay
available.

## When to use a fixed language

Use a fixed language when you want a more controlled public experience. This is
useful if your workspace is meant for one market, one region, or one language
only. When you choose a fixed language, all visitors see the same language on
your public pages.

# Mask public identities

Source: https://userjot.com/support/mask-public-identities
Section: Workspace Setup
Updated: 2026-10-06

> Hide team members' names and avatars on public pages and in notifications so your team appears as the company, not as individuals.

Masking public identities hides regular users' names and avatars on public
pages and notifications. Workspace owners and admins stay visible, and each
person still sees their own name on their own posts. Your team still sees
full identities inside the workspace.

## Enable mask public identities

1. Open **Settings** in your workspace, then go to

   **Privacy**.

2. Under **Public board**, find the

   **Mask public identities** setting.

3. Turn it on to hide regular user names and avatars
   on public pages and notifications.

## What changes when it is enabled

This setting is meant for public-facing spaces. It hides regular users' names
and avatars from external viewers on your public board, in conversations,
updates, and other public activity.

Use it when you want to collect feedback publicly without exposing who posted
or commented.

## What does not change

Your team stays visible. Workspace owners and admins keep their names and
avatars on public pages. Each person still sees their own name on posts they
wrote.

Teammates inside the workspace still see full identities in the dashboard and
can continue working normally.

This setting is about the public presentation of identity, not about changing
how your team manages feedback internally.

## Plan availability

Masking public identities is available on the Professional plan. On other
plans, the setting is visible but disabled until you upgrade.

# Automatic login

Source: https://userjot.com/support/automatic-login
Section: Workspace Setup
Updated: 2026-09-16

> Automatically recognize signed-in users when they open your feedback portal.

Automatic login lets UserJot recognize people who are already signed in to your
product. Instead of asking those users to log in again when they open your
feedback board, UserJot can carry their identity through automatically.

This is useful when you want a smoother experience between your app and your
public UserJot pages. It reduces friction for signed-in users and makes it
easier to keep feedback tied to the right person.

## Enable automatic login

1. Open **Settings** in your workspace, then go to

   **Login**.

2. Under **Authentication**, find the

   **Automatic login** setting.

3. Turn it on if you want signed-in users from your
   product to be recognized automatically when they open your board.

4. If you want a stricter setup, turn on
   **Require signed tokens** as well. This option
   appears on the page once automatic login is on.

Automatic login is available on paid plans. On the Free plan, the toggle is
visible but disabled until you upgrade.

## What the signed token setting does

The signed token option adds another layer of trust to the automatic login
flow. When it is enabled, automatic login only works when your integration
passes properly signed identity data to UserJot.

For most teams, this is the more secure setup. If you are deciding between the
two, it is reasonable to start by understanding the feature here and then use
the docs when you are ready to implement it.

## Where to find the technical setup

The support page is meant to explain the feature and the settings. For the
technical integration steps, use the implementation guide in our docs section.

# Single sign-on

Source: https://userjot.com/support/single-sign-on
Section: Workspace Setup
Updated: 2026-09-16

> Configure SSO so access to UserJot is controlled by your identity provider.

Single sign-on changes how people log in to your public board. Instead of using
the default UserJot login flow, users are redirected to your own authentication
page and then sent back after they sign in.

In UserJot, SSO is configured as a **board login mode**. That means it replaces
the normal board login experience rather than acting as a separate optional
button.

## Enable single sign-on

1. Open **Settings** in your workspace, then go to

   **Login**.

2. Under **Authentication**, find the

   **Board login** setting.

3. Select **SSO** if you want your public board to use
   your own authentication flow instead of the default UserJot login.

4. The first time you choose SSO, an **Enable SSO** dialog asks for your
   redirect URL. Enter the `https://` URL where users should authenticate,
   then confirm with **Enable SSO**.

5. The mode applies immediately. Users who click
   **Sign In** on the board are sent to your
   authentication page. To change the URL later, edit
   **SSO redirect URL** on the same page and select
   **Save**.

## What changes when SSO is enabled

SSO replaces the default board login flow. When users try to sign in from your
board, they are redirected to your authentication page instead of going through
UserJot's normal login.

This is useful when your company already manages authentication in its own app
or identity provider and you want board access to follow the same rules.

## Board login modes

The **Board login** setting controls how login works
on your public board:

- **Default** uses the standard UserJot login flow.
- **SSO** redirects users to your authentication page.
- **Disabled** hides the login button entirely.

Board login modes require the Professional plan. On other plans, the setting
is visible but locked.

## Where to find the technical setup

The support page is meant to explain the feature and the settings. For the
technical implementation steps, use the implementation guide in our docs
section.

# Overview

Source: https://userjot.com/support/import-data
Section: Import Data
Updated: 2026-10-06

> Bring existing feedback into UserJot from Canny, Nolt, ProductRoad, or any CSV export, with what each import carries over and how to prepare.

Importing data into UserJot is straightforward, and in most cases we recommend
doing it early instead of starting from a blank workspace. It gives your team
historical context right away and makes it easier to keep momentum when moving
from another tool.

UserJot supports multiple import paths, including CSV, Canny, Nolt, and
ProductRoad. Each one has its own setup flow, so the best next step is to open
the guide for the source you are migrating from.

If you are not sure where to start, CSV is the most flexible option. If you are
coming from a supported feedback tool, using the direct import flow is usually
faster and easier.

## Imported votes and Trending

UserJot preserves the vote totals provided by your import. Some sources also
include individual votes and their dates, while others only provide a total.

Imported requests can appear in a different order in Top and Trending. Top
uses the displayed vote totals, while Trending reflects recent customer
interest. Importing an older request does not make its existing votes new.

If an imported request has a high vote count but appears lower in Trending,
that does not mean its votes were lost. See
[how Trending works](https://userjot.com/support/how-trending-works) for more on the different
ways to sort feedback.

# Import from Canny

Source: https://userjot.com/support/import-from-canny
Section: Import Data
Updated: 2026-10-06

> Import your Canny boards, posts, votes, comments, and changelog entries into UserJot in one run, with a map of how each Canny field lands.

UserJot includes a direct import flow for Canny. Instead of exporting data by
hand, you connect your Canny account, review the mappings, and then start the
import from the dashboard.

## Import from Canny

1. Open **Settings** in your workspace, then go to

   **Data & Import**.

2. In the **Import** section, click

   **Import from Canny**.

3. Enter your Canny API token and continue.

4. Review how your Canny boards map to boards in UserJot, then review how your
   Canny statuses map into UserJot statuses.

5. Confirm the import and select **Import Submissions**
   to start it.

## What the importer asks you to map

The Canny import flow focuses on two decisions: board mapping and status
mappings.

Board mapping tells UserJot where imported feedback should land. Status mapping
makes sure feedback from Canny keeps a sensible workflow once it arrives in
UserJot.

If Canny does not return statuses in the import flow, UserJot falls back to a
default status mapping and you can adjust things later inside the workspace.

## What gets imported

UserJot imports posts, votes, non-empty comments, and changelog entries. Images
attached to posts and comments are copied as part of the import.

The importer also creates or matches a member for each post author, comment
author, and voter. This keeps authorship and votes connected to the right
people. If the same person appears more than once, UserJot matches them by their
external user ID or email address to avoid duplicates.

Canny users who have not authored a post, written a non-empty comment, or voted
on an imported post are not imported. The import does not copy Canny login
credentials or grant anyone an admin role in UserJot.

## Before you start

Make sure you have the right API token from your Canny account before opening
the importer. Once connected, UserJot will populate the available boards and
statuses for review.

The import runs asynchronously after you confirm it, so you do not need to stay
on the page while it finishes.

# Import from ProductRoad

Source: https://userjot.com/support/import-from-productroad
Section: Import Data
Updated: 2026-10-06

> Move your ProductRoad feedback into UserJot: export your data, run the import, and see how boards, posts, votes, and statuses come across.

UserJot includes a direct import flow for ProductRoad. You connect your
ProductRoad account with an API token, review how boards should map into
UserJot, and then start the import.

## Import from ProductRoad

1. Open **Settings** in your workspace, then go to

   **Data & Import**.

2. In the **Import** section, click

   **Import from ProductRoad**.

3. Enter your ProductRoad API token and continue.

4. Review how ProductRoad boards should map to boards in UserJot, including the
   default board for anything that does not map directly, then select

   **Import**.

5. Confirm the import and select **Import Submissions**
   to start it.

## What this import covers

The ProductRoad flow is simpler than CSV and Nolt because it focuses on board
mapping instead of walking you through field-by-field setup.

Once the connection succeeds, UserJot shows the available ProductRoad boards so
you can decide where each one should land in your workspace.

## Before you start

Have your ProductRoad API token ready before opening the import flow. UserJot
uses that token to connect to ProductRoad and load the available data.

After you confirm the import, the migration starts in the background. You do
not need to stay on the page while it runs.

# Import from Nolt

Source: https://userjot.com/support/import-from-nolt
Section: Import Data
Updated: 2026-10-06

> Move your Nolt board into UserJot: export from Nolt, run the import, and see how boards, posts, votes, and statuses come across.

UserJot includes a direct import flow for Nolt. You connect your Nolt board
with its board URL and API token, choose where the imported posts should go,
and then confirm the import.

## Import from Nolt

1. Open **Settings** in your workspace, then go to

   **Data & Import**.

2. In the **Import** section, click

   **Import from Nolt**.

3. Enter your Nolt board URL and your Nolt API token.

4. Choose which board in UserJot should receive the imported posts, then review
   the status mapping.

5. Confirm the import and select **Import Submissions**
   to start it.

## What makes the Nolt import different

Unlike the Canny flow, the Nolt importer asks for both a board URL and an API
token. That combination tells UserJot which Nolt board to connect to and which
data to import.

The importer then asks you to choose a target board in UserJot and map any
statuses that come from Nolt so the imported feedback fits your current
workflow.

## Before you start

Have both the board URL and API token ready before opening the import flow.
UserJot uses the board URL to locate the source board and the token to access
the data.

If your Nolt statuses do not line up exactly with your UserJot workflow, you
can adjust the mapping during setup and refine statuses later if needed.

# Import from CSV

Source: https://userjot.com/support/import-from-csv
Section: Import Data
Updated: 2026-10-06

> Upload a CSV of feedback exported from any tool, map its columns to UserJot fields, and import posts, votes, and statuses into a board in one pass.

Importing from CSV is the most flexible option when your feedback already lives
in a spreadsheet or can be exported into a flat file. UserJot guides you
through the import step by step so you can match your columns to the right
fields before anything is imported.

## Import from CSV

1. Open **Settings** in your workspace, then go to

   **Data & Import**.

2. In the **Import** section, click

   **Import from CSV**.

3. Upload your CSV file. Files with up to 10,000 rows work best in the current
   importer.

4. Map your CSV columns in each step of the flow. UserJot walks you through
   submission fields, author fields, submission details, status mapping, and
   board mapping.

5. Review the import summary, then select
   **Import Submissions** to start the import.

## What to expect during mapping

CSV imports are the most configurable import path. That is why the importer
asks you to confirm how your file should map into UserJot instead of assuming
everything automatically.

You can map titles, body content, votes, authors, board names, statuses, and
timestamps. If your file includes multiple boards or custom statuses, this step
is where you decide how they should appear in UserJot.

## Before you upload the file

It helps to make sure your CSV is clean before you start. Clear column names
and consistent values make the mapping steps much easier to review.

If your file includes status or board values that do not match UserJot exactly,
that is fine. The importer gives you a chance to map them before the import
runs.

# Create a board

Source: https://userjot.com/support/create-a-board
Section: Boards & Feedback
Updated: 2026-10-06

> Create a new feedback board for a product area or channel, name it, set its visibility, and decide who can post before you share the link.

Boards help you organize feedback around a product area, team, or type of
request. Most teams start with one or two clear boards, then add more only when
it makes feedback easier to submit and easier to manage. Free includes 2
boards, Starter includes 5, and Professional is unlimited.

1. Open **Settings** and go to

   **Feedback**.

2. In the **Boards** section, click

   **New board**.

3. Enter a clear board name. Good board names are easy for users to understand
   right away, such as `Feature Requests`, `Bug Reports`, `Mobile App`, or
   `API`.

4. Choose a color for the board. Color helps you distinguish boards quickly in
   the dashboard, but it does not change how the board works.

5. Click **Create** to add the board to your
   workspace.

After the board is created, you can reorder it, rename it, or delete it later
from the same **Feedback** settings page. A board with
submissions cannot be deleted until those submissions are moved or removed.

All new boards start as public. If your plan supports private boards, you can
change the board type afterward from

**
  Public
**
to
**
  Private
**
.

Keep your board structure simple at the start. If users are unsure where to
post, you probably have too many boards. A small number of clearly named boards
usually works better than trying to model every team or workflow on day one.

# Triage requests

Source: https://userjot.com/support/manage-requests
Section: Boards & Feedback
Updated: 2026-10-06

> Triage incoming requests: review new posts, merge duplicates, tag and assign them, and move each one through statuses that feed your roadmap.

Managing requests in UserJot is built around a simple workflow. New posts start
in triage, then move through review, planning, delivery, and completion. The
fastest way to manage that flow is the action bar on the request page, which
shows the next decision you are most likely to make.

1. **Triage new requests.** New requests start in

   **Pending**. This is where you decide whether a post
   should move forward, be merged into an existing request, or be closed. The
   action bar gives you those decisions directly: accept it, merge it, or close
   it. If you are working through the queue, accepting or closing a request
   takes you straight to the next pending item. Only requests everyone can see
   can be merged. The merge button explains why when a request is on a private
   board, hidden, or waiting for review.

2. **Review what is worth doing.** Accepted requests move to

   **Reviewing**. This is the filtering stage. Your team is
   deciding whether the request is real, useful, and important enough to plan.
   From here, the usual next step is to close it or mark it
   **Planned**.

3. **Plan work that you intend to deliver.** Requests in

   **Planned** are ideas you expect to work on, but have
   not started building yet. This is where your roadmap starts to take shape.
   When a request is marked **Planned**, it appears on the
   roadmap automatically if it is approved and public. From here, you can move
   it back to
   **Reviewing** if it is not ready, or start work when the
   team is ready to build.

4. **Move active work into progress.** When work starts, move the request to

   **In Progress**. This tells users and teammates that
   the request is being worked on now. Approved public requests also appear in
   the roadmap's in progress state. If work pauses, you can move it back to
   **Planned**. When it ships, mark it
   **Completed**.

5. **Close the loop after shipping.** Completed requests are done, but the
   workflow does not really end until users hear about it. From

   **Completed**, the action bar prompts you to draft a
   changelog entry so you can publish the update and close the loop publicly.

6. **Use closed for requests you are not taking forward.** A request should be
   marked **Closed** when you are not planning to work on
   it, when it is out of scope, or when it has been superseded. Closed requests
   can still be reopened later, and reopening sends them back to
   **Reviewing**.

UserJot also highlights requests that need attention even when their status has
not changed. Planned or in-progress work becomes stale if it sits too long
without movement, and the action bar then asks you to move it back to

**Reviewing** or keep it where it is. A review item with very
low engagement shows up as a low-traction reminder, and the action bar asks you
to keep it open or close it.

If you need to make a direct change, click the status pill on the request, the
first pill under the post, and pick the exact status you want. That is useful
when you already know where a request should go. For day-to-day work, though,
the action bar is the clearest way to keep requests moving through the intended
workflow.

## Workflow, review, and visibility

A request's status describes what your team plans to do with it. Moderation
controls whether its content has been approved, and a pill sets who can see it
(On board, Hidden, In review).

Accepting a request or moving it to another status does not approve content
that is waiting for moderation. Closing a request does not reject or delete
its content either. Use the **Needs review** panel to resolve the review.

Hidden requests and requests awaiting approval stay off the public board and
roadmap, even when they are planned or in progress.

See [moderate content](https://userjot.com/support/moderate-content) for review actions, or
[hide a request from the board](https://userjot.com/support/make-a-request-private) to change who
can see a request.

## Understand the Trending badge

A request in **Reviewing** may show a **Trending** badge in
the dashboard when it has received recent votes. Use it to spot requests worth
another look as you work through the queue.

The badge is a dashboard cue. The public board's Trending sort determines the
order of the requests shown there, so a badge does not guarantee a particular
position on the board.

See [how Trending works](https://userjot.com/support/how-trending-works) for the difference between
Top, Trending, and Newest.

# Auto-tag feedback

Source: https://userjot.com/support/auto-tag-feedback
Section: Boards & Feedback
Updated: 2026-10-06

> Turn on auto-tagging so AI applies the right tags to each new request as it arrives, keeping your boards grouped and searchable without manual sorting.

Auto-tagging helps you organize feedback faster by using AI to choose the most
relevant tags for a request. It works best when you already have a small, clear
set of feedback tags that represent the categories your team actually uses.

1. **Create your feedback tags first.** Auto-tagging does not create tags for
   you. It only selects from the feedback tags that already exist in your
   workspace. To create them, open **Settings**, go to

   **Feedback**, and use the
   **New tag** button in the
   **Tags** section.

2. **Use clear tag names.** Tags work best when they describe stable
   categories, not one-off ideas. Good examples include `Bug`, `Feature
Request`, `Performance`, `Billing`, `API`, or `UI`. Try not to create
   several tags that mean almost the same thing, because that gives AI weak
   choices and makes filtering less useful later.

3. **Run auto-tagging on a request.** Open a request, then click the

   **Auto-tag** sparkle action next to the tag pills at
   the bottom of the request. You can also run
   **Auto tag** from the
   **Tags** menu when you right-click a row in the
   requests list.

4. **Review the result.** Auto-tagging looks at the request title and body,
   then selects the most relevant existing tags. It can apply up to three tags,
   and in some cases it may return none if none of the available tags are a
   strong fit.

5. **Adjust tags when needed.** Auto-tagging is meant to speed up triage, not
   replace judgment. If a request needs a different tag set, you can still add
   or remove tags manually from the same request.

If you change your tag system later, rerun auto-tagging on older requests that
you want to clean up. Re-running replaces the full tag set on that request,
including tags you added by hand. UserJot matches against your current
available tags, so better tags usually lead to better results.

Keep your tag system simple. A short list of clear tags usually performs better
than a long list of overlapping categories.

# Merge duplicates

Source: https://userjot.com/support/merge-duplicates
Section: Boards & Feedback
Updated: 2026-09-05

> Keep one canonical request when multiple posts describe the same thing.

Merging duplicates helps you keep feedback organized around one canonical
request. Instead of splitting votes, comments, and discussion across several
posts, you keep one main request and merge the duplicates into it.

1. **Use merge when requests mean the same thing.** A duplicate does not need
   to use the exact same words. If two requests are really asking for the same
   outcome, merging them usually gives your team a cleaner queue and gives users
   a better single place to follow the discussion.

2. **Start with the suggested matches.** When you open the merge flow from a
   request, UserJot first shows suggested duplicates automatically. These
   suggestions are based on similarity, so the most likely matches appear
   before you type anything.

3. **Use search when the suggestion list is not enough.** If the request you
   want is not in the suggested list, start typing in the merge search. This
   switches to normal text search so you can find the right request by title or
   description.

4. **Choose the canonical request carefully.** The request you merge into
   becomes the main request that stays active. In most cases, the best target is
   the clearer request, the older request, or the one that already has the
   strongest discussion around it.

5. **Know what gets merged.** When you merge a duplicate into a main request,
   UserJot moves the duplicate's comments onto the main request and carries over
   distinct reactions so useful signal is not lost. If the same person already
   reacted on the main request, that reaction is not duplicated.

6. **Know what does not get merged.** The duplicate request is not deleted. It
   becomes a merged request linked to the main one. Request subscriptions are
   also not automatically moved over, so the main reason to merge is to unify
   discussion and signal, not to merge every relationship perfectly.

7. **Review the result after merging.** The merged request will show that it
   was merged into another request, and the main request will show which other
   requests were merged into it. This makes it easier for your team to keep the
   history understandable and undo the merge later if needed.

If you need to reverse the decision, you can unmerge the request. UserJot will
restore the moved comments, remove copied reactions from the main request, and
turn the duplicate back into a standalone request.

## How merging affects Trending

Merging brings the requests' existing support together. Votes carried over from
the duplicate keep their original dates, so merging does not turn earlier
votes into new activity. A person who voted on both requests still counts once
on the main request.

Trending updates after a merge or an unmerge to reflect the votes on each
request. See [how Trending works](https://userjot.com/support/how-trending-works) if the order looks
different from the displayed vote totals.

Use merging to keep one clean request per problem. It works best when your team
merges early, before discussion spreads across several nearly identical posts.

# Guest feedback

Source: https://userjot.com/support/guest-feedback
Section: Boards & Feedback
Updated: 2026-10-06

> Allow people to post feedback and vote without creating an account first, so a visitor can leave an idea in one step, and see what is still gated.

Guest feedback lets people participate on your public board without creating an
account first. This is one of the simplest ways to reduce friction and collect
more feedback from users who would otherwise leave before signing in.

## Enable guest feedback

1. Open **Settings** in your workspace, then go to

   **Privacy**.

2. Under **Public board**, find **Guest submissions**.

3. Turn it on to allow visitors to participate
   without signing up first. The change applies immediately.

4. Share your public board link so users have one place to post feedback, vote,
   and join existing discussions.

Guest submissions are available on paid plans. On the Free plan, the toggle is
visible but disabled until you upgrade.

## What guests can do

When guest feedback is enabled, visitors can submit requests, vote on existing
posts, and add comments on your public board. This makes it easier to capture
feedback from first-time users, trial users, or anyone who does not want to
create an account before participating.

## What guest feedback does not change

Guest feedback does not open up every part of your workspace. Guests see
approved public content. When UserJot can identify someone through their guest
session, they can also return to their own submissions and the comments on
them, even when a post is private or waiting for review. Private boards still hide
other people's posts, though a guest can submit to one if it is listed in the
board picker.

An anonymous receipt or a copied link does not grant access to a private post.
If a guest session is lost, the visitor may no longer be recognized as the
author.

If guest feedback is turned off, people need to sign in before they can
participate. That sign-in flow depends on your board login settings.

## Guest feedback and moderation

Guest requests and comments follow your workspace's moderation settings.
Automatic checks can also flag content for review.

A confirmation means the feedback was received. It may still need checking or
approval before other people can see it. Authors may see **Checking your
feedback** or **Pending Review**, while the widget shows a receipt message.

Your team handles the review in the dashboard. See
[moderate content](https://userjot.com/support/moderate-content) for settings and review actions.

## When to use guest feedback

Guest feedback works well when your goal is to make participation as easy as
possible. It is especially useful for public product boards, bug-report boards,
and early-stage products where reducing signup friction matters more than
capturing a full user profile on the first interaction.

# Private boards

Source: https://userjot.com/support/private-boards
Section: Boards & Feedback
Updated: 2026-10-06

> Use a private board when every post should be visible only to its author and your team, such as for bugs or account-specific requests.

Private boards are useful when feedback should not be visible to everyone on a
public board. Instead of turning requests into a shared public discussion, a
private board keeps each submission scoped to the person who created it and
your workspace admins.

## Change a board between public and private

Boards are created as public by default. To change a board later:

1. Open **Settings** in your workspace, then go to

   **Feedback**.

2. In **Boards**, find the board you want to
   change.

3. Click the board's visibility pill, which shows
   **
     Public
   **
   or
   **
     Private
   **
   , and choose the other option. The change applies immediately.

## How private board visibility works

Private boards use a different visibility model from public boards:

- Workspace admins and owners can see all submissions on the board.
- Each author can see their own submissions on the board.
- Other users cannot see submissions they did not create.
- Guests do not see other people's posts. Authors can return to their own
  posts and comments while UserJot can identify them through their guest session.

That means a private board is not a public list of requests with restricted
voting. It is a board where submissions stay visible to the author and your
internal team only.

## Hide one request on a public board

You can [hide an individual request](https://userjot.com/support/make-a-request-private) without
changing its board by choosing Hidden from board. This lets you keep an
account-specific request between its author and your team while other approved
posts remain open for discussion.

A request shown on the board still follows its board's access rules. It cannot
become publicly visible while it belongs to a private board.

## When to use a private board

Private boards work best when feedback includes details that should not be
shared widely. Common examples include bug reports, account-specific requests,
enterprise customer feedback, or internal product requests that should stay
confidential.

If the goal is open discussion, shared voting, and visible prioritization, use
a public board instead. If the goal is controlled visibility, use a private
board.

## What users see

People can still submit feedback into a private board, but they do not browse
other users' submissions there the way they would on a public board. A user can
come back to see their own posts, while admins and owners can review the full
board inside the workspace.

This makes private boards a good fit when you want to collect feedback through
the same workflow without exposing every request to every visitor.

## Plan availability

Private boards are available on the Starter and Professional plans. On the
Free plan, the

**
  Private
**
option is visible but disabled.

# Moderate content

Source: https://userjot.com/support/moderate-content
Section: Boards & Feedback
Updated: 2026-09-30

> Review feedback for spam, abuse, and sensitive information before sharing it publicly.

Moderation gives your team a chance to review feedback before other people see
it. You can require approval for new requests or comments, check for sensitive
information, and review content flagged as possible spam or abuse.

Workspace admins and owners handle reviews in the dashboard. They can also
review comments from the public request page.

## Choose what needs review

Open **Settings**, then go to

**Privacy**. Under **Public board**, you can turn on:

- **Moderate submissions**, to require approval for new requests from customers
  and guests.
- **Moderate comments**, to require approval for new public comments from
  customers and guests.
- **Detect sensitive information**, to check new or edited feedback for private
  details before it appears publicly.

These settings are available on Starter and above. Turning off a setting does
not approve content that is already waiting for review.

Admins and owners bypass the manual approval requirement. Sensitive-information
checks still apply to their requests and public comments when enabled.

## Automatic spam and abuse checks

UserJot checks requests and comments for possible spam and abuse. Flagged
content can move into review even when you have not required manual approval
for every post.

Abuse includes personal attacks, harassment, threats, and targeted slurs.
Customers can still criticize your product or express frustration. A report
that quotes an abusive message is different from directing abuse at someone.

Automatic checks can make mistakes. Your team decides whether flagged content
should stay.

## Check for sensitive information

With **Detect sensitive information** enabled,
UserJot checks feedback text and uploaded JPEG, PNG, and WebP images for private
details such as credentials, financial information, and personal disclosures.
Feedback stays out of public view while the check runs.

An unsupported or unreadable image may need manual review. Other attachment
types are not checked. Detection can miss sensitive information, so review the
content yourself before publishing it.

## Review a request

Open the request in the dashboard. The **Needs review** panel shows why it is
waiting and the actions available.

For possible spam or abuse:

- Choose **Keep** if the content should stay. This
  clears the spam and abuse findings shown in the panel and keeps the request's
  Shown on board or Hidden from board setting.
- Choose **Delete** to remove the request. You will be
  asked to confirm before it is deleted.

If another reason remains after you choose Keep, the request still needs
review. For example, it may also contain sensitive information.

For manual review or sensitive information:

- On a public board, choose **Publish** to finish the
  review and show the request on the board, or
  **Keep hidden** to finish the review and keep the
  request visible only to its author and workspace admins and owners.
- On a private board, choose **Approve**. Only the
  author and your team can see requests there.

You can edit the title or description directly before making a decision. Wait
for the changes to save and any new checks to finish. If someone changes the
request while you are reviewing it, review the latest version before trying
again.

A request's workflow status is separate from moderation. Accepting it, planning
it, or closing it does not resolve a review. See
[triage requests](https://userjot.com/support/manage-requests) for the workflow and
[hide a request from the board](https://userjot.com/support/make-a-request-private) for
visibility.

## Review a comment

Select the orange **Review** button beside Reply to
see the reasons and actions. The dropdown works in the dashboard and on the
public request page when you are signed in as an admin or owner.

Comments flagged as possible spam or abuse offer Keep and Delete. As with
requests, Keep clears those findings while leaving any other review reasons
in place. Delete asks for confirmation.

For other comment reviews, choose **Approve** to allow
the comment, or **Don't publish** to leave it
unapproved. Don't publish keeps the comment for your team to review later;
it does not delete it.

Approving a comment does not make its request public. The request and any
parent comment must also allow it to appear to other people. To keep the whole
discussion between the author and your team, hide the request from the board.

## When a check cannot finish

If a check fails, the review control shows **Check could not finish**. Choose

**Retry check** to try again. The content stays out of
public view until the check or an admin review resolves it.

## What the author sees

Authors may see **Checking your feedback** or **Pending Review** after submitting.
Their feedback has been received, but it is not public yet. Detailed review
reasons and moderation actions are visible only to admins and owners.

The widget also confirms receipt without promising that the feedback has been
published. See [guest feedback](https://userjot.com/support/guest-feedback) for how guests return
to their own posts.

# Hide a request from the board

Source: https://userjot.com/support/make-a-request-private
Section: Boards & Feedback
Updated: 2026-10-06

> Hide a single request on a public board so only its author and your workspace admins can see it, without moving it to a private board.

A request can be hidden while it belongs to a public board. Use this for
account-specific feedback or details that should stay between the author and
your team.

## Hide the request

1. Open the request in your workspace dashboard.
2. Find the **On board** pill below the description.
3. Choose **Hidden from board**. The change applies
   immediately.

Only workspace admins and owners can change this setting. The request keeps
its current workflow status, so your team can continue reviewing, planning,
or working on it.

## Who can see a hidden request

Workspace admins and owners can see the request. Its author can also return
to it when UserJot can identify them through their account or guest session.
Other users cannot open it or find it on the public board or roadmap.

Sharing a link does not give someone access to a hidden request. Comments
follow the request's access rules, and approving a comment does not make the
discussion public.

## Show it on the board again

Choose **Shown on board** from the same pill. For the
request to appear publicly, it must also belong to a public board and have
completed any required moderation review.

On a private board this setting only appears if the request was hidden
earlier, because only the author and your team can see those requests anyway.
Choosing Shown on board clears it, and the private board still limits who can
see the request. See [private boards](https://userjot.com/support/private-boards) if you want the
same visibility rules for every request on a board.

## Keep a request hidden during moderation

If a request is waiting for manual review or contains sensitive information,
the review panel offers **Keep hidden** and

**Publish** on public boards, and
**Approve** on private boards. Keep hidden finishes the
review and hides the request in one step.

Changing the pill by itself does not resolve a review. For possible spam or
abuse, **Keep** clears those findings and preserves
the visibility you have chosen. Other review reasons may still need attention.

Read [moderate content](https://userjot.com/support/moderate-content) for the full review flow.

## Content that was already shared

Hiding a request cannot take back copies people have already seen,
downloaded, or received by email. Previously shared direct attachment links
may still work. Remove sensitive details before publishing whenever possible.

# How Trending works

Source: https://userjot.com/support/how-trending-works
Section: Boards & Feedback
Updated: 2026-09-05

> Understand the difference between Top, Trending, and Newest on your feedback board.

Your feedback board gives you a few ways to browse requests. Each sort helps
you answer a different question, whether you want to see recent interest,
the most votes, or the latest posts.

## Choose a sort

Use the sort menu on your public board to switch between:

- **Top** shows requests with the highest displayed vote totals first.
- **Trending** highlights requests getting recent customer interest.
- **Newest** shows the most recently created requests first.

Choose Top when you want to compare vote totals. Choose Trending when you want
to see what customers are showing interest in now. Newest is useful when you
want to catch up on recently submitted feedback.

## Why a request with fewer votes can appear higher

A request getting attention now can appear above one that collected more votes
some time ago. Trending takes recent interest into account, so its order can
look different from Top.

The vote count shown on each request stays the same whichever sort you choose.
A lower position in Trending does not mean votes were removed. You can switch
back to Top at any time to compare the displayed totals.

## How the order changes

Trending updates as people submit requests and vote. An older request can move
up when customers show renewed interest in it.

Being high in Trending does not mean a request is planned or being worked on.
Check its status or the [public roadmap](https://userjot.com/support/plan-work) to see what the team
has decided to build.

## Imported and merged requests

Existing feedback keeps its history when you bring it into UserJot or merge
duplicates. Those actions do not turn earlier votes into new activity.

See [importing feedback](https://userjot.com/support/import-data) and
[merging duplicates](https://userjot.com/support/merge-duplicates) for what happens to the requests
and their votes.

# Plan work

Source: https://userjot.com/support/plan-work
Section: Roadmap & Changelog
Updated: 2026-10-06

> Move requests through statuses like Planned and In Progress so your public roadmap updates itself and voters hear about each change.

Your roadmap updates automatically from request status. You do not need to add
items to it manually. As requests move through your workflow, they appear in
the right roadmap phase for users to follow.

## Enable the public roadmap

1. Open **Settings** in your workspace, then go to
   **Feedback**.
2. Under **Behavior**, find **Public roadmap**.
3. Turn it on to show the roadmap tab on your
   public board.
4. Move requests into the right statuses as you review and plan work.

This toggle only controls the public board. Your internal roadmap in the
dashboard stays available either way.

## How public roadmap columns map to statuses

The public roadmap has three columns:

- **Planned** shows requests marked **Planned**.
- **In Progress** shows requests marked **In Progress**.
- **Done** shows requests marked **Completed**.

That means the roadmap is really a public view of your workflow. If you want a
request to move from planning into active work, change its status.

## What does not appear on the public roadmap

Requests marked **Pending**,

**Reviewing**, or **Closed** do not
appear on the public roadmap. Completed work stays visible in the **Done**
column, so users can see what recently shipped.

## The dashboard roadmap

Your workspace also has an internal **Roadmap** page
in the dashboard sidebar. It shows every status as its own column, from

**Pending** through **Closed**, and
you can drag a request between columns to change its status. It is always
available to your team, even when the public roadmap is turned off.

# Publish updates

Source: https://userjot.com/support/publish-updates
Section: Roadmap & Changelog
Updated: 2026-10-06

> Write and publish changelog entries for shipped work, link them to the requests they close, and let Juno draft the post from what you completed.

Updates in UserJot are published through the changelog. Use them to explain
what changed, give users context, and close the loop on completed work.

## Publish an update

1. Open **Changelog** in the dashboard.
2. Click **New Entry** to create a new update.
3. Add a clear title and write the body of the update.
4. Set the publish date, then publish it when it is ready.

## Start from a completed request

If a request is already marked **Completed**, you can
also start from the request itself.

In the request action bar, click **Draft Changelog**
to jump straight into a new draft in the changelog editor. The draft starts
empty, so write the update there the same way you would from

**New Entry**.

## What you can add to an update

Inside the editor, you can set the title, slug, content, publish date, cover
image, authors, and changelog tags.

Keep the update focused on what changed and why it matters. The best entries
are short, specific, and easy to scan.

## Link the feedback behind the work

When requests are linked to an update, they show on the update page under
**Built from your feedback**. That helps users see which requests led to the
change. Each viewer only sees the requests they could see on your boards:
requests on private boards, submissions still pending moderation, and requests
that were merged into another are left out.

Linking requests to a changelog entry is currently available through the
UserJot API rather than the editor. If you do not use the API, updates publish
normally without linked requests.

## Drafts, published entries, and scheduled entries

New entries start as drafts. They stay internal until you publish them.

If an entry is published with a future publish date, it becomes scheduled and
will go live at that time. If it is published with a current publish date, it
appears immediately in **Updates**.

# Notify subscribers

Source: https://userjot.com/support/notify-subscribers
Section: Roadmap & Changelog
Updated: 2026-10-06

> How people who posted, voted, or commented on a request get an email when its status changes, and how to control what each update sends.

UserJot helps people stay informed as feedback moves through your workflow.
Instead of requiring manual follow-up, users can subscribe to requests and
receive updates when something changes.

## How users follow a request

Users can follow a request directly with

**Follow this post** in the actions section on the
public request page. The same button becomes
**Unfollow this post** once they follow.

Most people never press that button, though. The author of a request is
subscribed from the start, and anyone who votes, comments, or replies on the
public board is followed up automatically. Participation is what keeps people
connected. The exception is activity created through the public API, which
does not subscribe anyone.

## What triggers notifications

The most important notification is a status change.

When a request moves from one status to another, UserJot can notify the people
connected to that request, including the author and other followers.

This is what closes the loop for feedback. Users can see when a request moves
into review, becomes planned, starts progressing, or is completed.

## Replies and discussion

UserJot also notifies people when discussion continues on a request.

If someone replies in a comment thread, the people already involved in that
thread can be notified so the conversation stays active without everyone having
to check back manually.

## Feedback that needs review

Announcements about new requests and comments can wait while the content is
being checked or awaiting approval. Workspace admins may still receive a
review alert.

Before sending an update, UserJot checks whether the recipient can still access
the content. Hiding a request limits further notifications to people
who retain access. It does not recall emails already delivered.

Approving content does not resend every earlier notification. Older creation
announcements may no longer be sent after a long review. Public digests also
leave out hidden or unapproved feedback.

See [moderate content](https://userjot.com/support/moderate-content) and
[hide a request from the board](https://userjot.com/support/make-a-request-private) for how
review and visibility affect feedback.

## Replying from email

Some notification emails let recipients reply directly from their inbox. When
an email says they can reply, UserJot turns the meaningful part of that reply
into a comment on the related request or comment thread.

Replies are accepted only from the email address that received the original
notification. Automatic replies and empty replies are ignored.

## Weekly digests

For a lighter notification model, you can also enable weekly digests.

Open **Settings**, go to

**Feedback**, and turn on
**Weekly digest emails** under **Behavior** if you want
users to receive regular summaries of recent public feedback activity.

Digests are useful when you want to keep engaged users informed without sending
an email for every single change.

## Email preferences

Recipients can manage their own email notification settings.

That means users can choose how they want to hear about status updates,
discussion, and other activity instead of relying on a single default for
everything.

Turning off all emails also stops optional UserJot emails, including onboarding
and setup reminders for workspace admins. Essential account emails, such as
password resets and team invites, may still be sent.

# Overview

Source: https://userjot.com/support/conversations-overview
Section: Conversations
Updated: 2026-10-06

> What Conversations is, what it includes, and how it fits next to feedback, roadmap, and changelog.

Conversations is live chat and a shared support inbox built into UserJot. Your
users message you from the widget that already shows your feedback, roadmap,
and changelog. Your team answers from the same dashboard where you triage
requests. Support and feedback stop being two separate tools.

Conversations is in beta. It is free while in beta and will join the paid plans
once it graduates. There is no per-seat pricing, so every owner and admin on
your workspace can work the inbox. For the product tour, see the
[live chat page](https://userjot.com/live-chat-software). This article covers how it works.

## What it includes

Turning on Conversations adds four things:

- **Chat in your widget.** The widget gets a **Messages** page where users
  start conversations and read replies. Chat is one channel of a
  conversation; email is the other.
- **A shared inbox in your dashboard.** A **Conversations** section appears in
  the sidebar with Queue, Open, and All views. Every owner and admin sees the
  same conversations and anyone can reply.
- **Juno, the AI operator.** Juno picks up new conversations, answers from the
  knowledge you give it, and hands the thread to your team when a human is
  needed. It never invents answers and never files feedback without the
  customer confirming first.
- **Email forwarding.** Forward your existing support address into the same
  inbox, so email and chat land in one place. No DNS changes.

## How it connects to feedback

Most support conversations contain a feature request or a bug. When a customer
describes one in chat, Juno searches your public boards for a matching
request, shows it to the customer, and files, votes, or follows on their
behalf once they confirm. The request then moves through your normal workflow:
triage, roadmap, changelog. Signed-in and identified users are added as voters
or followers, so they get the same status updates as anyone who posted on the
board.

In the dashboard, a conversation's details panel lists every request linked to
it, and identified users show their product activity and contributions next to
the thread.

## Names you will see

- **Conversations** is the feature. It is the name of the settings group, the
  dashboard sidebar section, and this help center group.
- A **conversation** is one thread with one customer, whether it started in
  chat or by email.
- **Messages** is the page in the widget where your users see their
  conversations.
- **Juno** is the AI operator inside Conversations. It shows up with its own
  name and avatar, so it is never mistaken for a teammate.
- **Operators** are the teammates whose avatars and availability customers
  see. Any owner or admin can reply without being an operator.

## Requirements

- Conversations needs v3 of the UserJot widget. If you are on the older
  widget, upgrade your embed first.
- Only workspace owners and admins can turn it on, configure it, and work the
  inbox. Members who only use your public board do not get inbox access.
- Chat appears in your widget the moment you enable it, so have someone ready
  to watch the Queue, or turn Juno on first.

## Where to go next

1. [Turn on Conversations](https://userjot.com/support/turn-on-conversations) enables the beta
   and walks through what changes.
2. [The conversations inbox](https://userjot.com/support/conversations-inbox) explains the Queue,
   Open, and All views and how to find any conversation.
3. [Reply to conversations](https://userjot.com/support/reply-to-conversations) covers replies,
   internal notes, slash commands, snooze, and reminders.
4. [Meet Juno](https://userjot.com/support/meet-juno) and
   [Teach Juno your product](https://userjot.com/support/teach-juno) set up the AI operator and
   its knowledge base.
5. [Email forwarding](https://userjot.com/support/conversations-email-forwarding) brings your
   support mailbox into the inbox.
6. [Operators and availability](https://userjot.com/support/operators-and-availability),
   [Away replies](https://userjot.com/support/away-replies), and
   [Customize chat in the widget](https://userjot.com/support/customize-chat-in-the-widget) shape
   what customers see from your team.

# Turn on Conversations

Source: https://userjot.com/support/turn-on-conversations
Section: Conversations
Updated: 2026-10-06

> Enable the Conversations beta to add live chat and a shared team inbox to your workspace, and see what changes for your users when it is on.

Conversations adds live chat to your widget and a shared inbox to your
dashboard, so support threads live next to the feedback, roadmap, and changelog
you already run. It also includes Juno, an AI operator that can handle first
replies, and email forwarding so your support address lands in the same inbox.

Conversations is currently in beta. It is free while in beta, and it will join
the paid plans once it graduates. Beta workspaces get notice before anything
changes.

## Before you turn it on

Two things are worth knowing up front:

- Conversations requires v3 of the UserJot widget. If you are still on the
  older widget, upgrade your embed first.
- Chat appears in your widget the moment you enable it, so make sure someone
  is ready to keep an eye on the inbox.

## Enable Conversations

1. Open **Settings** in your workspace, then go to

   **Conversations**. Only workspace owners and admins
   can see this section.

2. On the **General** page, find **Turn on
   Conversations** and select **Turn on**.

That is the whole setup. Chat is live in your widget immediately, and a
**Conversations** section appears in your dashboard sidebar with Queue, Open,
and All views.

## What appears after you enable it

The Conversations settings group expands to include:

- **Operators** for team availability and hours
- **Email** for forwarding addresses
- **Widget** for the greeting, visitor details, and
  reply-time expectations
- **Juno AI** for the AI operator and its knowledge
- **Moderation** for blocked senders and IP rules

## Who can use it

Owners and admins configure Conversations and work the inbox. Regular members
who only participate on your public board do not get inbox access. There is no
per-seat pricing, so your whole team can join.

## Turning it off

The same page has the switch. Turning Conversations off removes chat from your
widget right away, but your conversation history stays. Turning it back on
picks up where you left off.

# The conversations inbox

Source: https://userjot.com/support/conversations-inbox
Section: Conversations
Updated: 2026-10-06

> How the conversations inbox is organized: what lands in Queue, Open, and All, how assignment and snooze move a thread, and how to find any conversation.

Once Conversations is on, a **Conversations** section appears in your
dashboard sidebar. It is a shared inbox: every owner and admin works from the
same conversations, and anyone can reply. Two things stay personal to you,
though: the reminders that surface in your Queue, and your Unread view.

## The three main views

The sidebar pins three views:

- **Queue** is home. It holds open conversations where the customer is waiting
  on your team, oldest waiting first with currently online visitors moved to
  the top, plus anything where you have a reminder due. When it is empty, no
  one is waiting on you. Queue and Open carry live counts.
- **Open** shows every open conversation except snoozed ones, most recent
  first.
- **All** shows everything in one list — open and resolved conversations,
  including snoozed ones — so resolved threads never disappear from view.

Queue is the one to work from. If Juno is handling a thread, it stays out of
your Queue until Juno hands it over or the customer needs a human.

## The other views

The filter at the top of the conversation list reaches everything else:

- **Unread** shows open conversations with messages you have not read yet.
- **Snoozed** holds open conversations hidden until a wake time.
- **Resolved** is where conversations go when you resolve them.
- **Spam** and **Archived** sit below a divider. They are out of the inbox
  entirely.

## Search

The search field above the list searches open, resolved, and archived
conversations. Spam is excluded. Search terms need at least 3 characters, and
queries are capped at 200 characters and 8 terms.

## Conversation details

Open a conversation and select **Show details** to
see who you are talking to: visitor details, environment, the page they
started from, any linked feedback requests, and for identified members, their
product activity and contributions.

Contacts that came from self-declared details rather than a verified sign-in
show an **Unverified** badge.

# Reply to conversations

Source: https://userjot.com/support/reply-to-conversations
Section: Conversations
Updated: 2026-10-06

> Reply to customers, leave internal notes, use slash commands, snooze a thread, and set reminders, all from the conversations inbox.

Everything you do in a conversation happens from the composer at the bottom of
the thread and the actions in the header.

## Replies and internal notes

The composer has two modes, switched with the chip next to the text field:

- **Reply** sends a message to the customer. They see it in the widget, and if
  they have an email address on file, they get it by email too.
- **Internal note** is only visible to your team. Notes never reach the
  customer.

Type `/` in the composer to open slash commands. They cover switching between
reply and note, resolving, reopening, archiving, marking spam, snoozing, and
setting reminders, all without leaving the keyboard.

## Resolve and reopen

When a conversation is done, select **Resolve** in
the thread header. Resolving is a label, not a lock: the composer keeps
working, and if the customer replies, the conversation reopens on its own.

To bring a resolved conversation back yourself, click the

**Resolved** button in the header, or use
**Reopen** from the conversation's row menu or the
slash commands.

## Archive and spam

The **More actions** menu in the header has

**Archive** and
**Mark as spam**. Both move the conversation out of the
inbox and lock the composer. Restore with
**Unarchive** or **Not spam**
if you change your mind.

## Snooze and reminders

These sound similar but solve different problems:

- **Snooze** is shared. It hides an open conversation from the inbox until a
  deadline, then brings it back. Use it when nothing can happen until later.
- **Remind me** is personal. Only you see the reminder, and when it comes due,
  the conversation appears in your Queue, even if it was resolved. Use it for
  your own follow-ups.

Both offer quick presets like tomorrow morning or next week, and both are
available as slash commands.

# Email forwarding

Source: https://userjot.com/support/conversations-email-forwarding
Section: Conversations
Updated: 2026-10-06

> Forward your support mailbox into the conversations inbox so email and chat sit in one place, without changing your domain's DNS.

Email forwarding brings your existing support address into Conversations.
Customers keep writing to `support@yourcompany.com` like they always have, and
their messages land in the same inbox as conversations started from the
widget.

There are no DNS changes involved. You create an address in UserJot, then set
up forwarding from your existing mailbox in Gmail, Google Workspace, Outlook,
or wherever your mail lives.

## Create a forwarding address

1. Open **Settings**, go to

   **Conversations**, then
   **Email**.

2. Select **Add address**. Give it a name and an
   address prefix, like `support`.

3. Select **Create address**. UserJot generates an
   address like `support@yourworkspace.userjot-mail.com`. Copy it.

4. In your mail provider, forward your support mailbox to that address.

The generated address cannot be changed later, so pick a prefix you like.
During the beta, each workspace gets one forwarding address, and all forwarded
mail lands together in one inbox.

## Setting up your mail provider

Every provider does step 4 a little differently. One thing that trips people
up: when a provider sends a verification email to your new address, that email
arrives as a conversation in your inbox. Open it there to get the link or
code.

**Gmail** — Gear → See all settings → Forwarding and POP/IMAP → Add a
forwarding address. Gmail emails a verification link to the UserJot address;
open that conversation, click the link, then go back to Gmail, refresh, and
turn on **Forward a copy of incoming mail to**. To forward only some mail,
verify the address first, then use a filter with **Forward it to** instead.

**Google Workspace** — Individual users follow the Gmail steps above, but an
admin has to allow forwarding first (Admin console → Apps → Google Workspace →
Gmail → End User Access → Automatic forwarding). To forward a whole mailbox
without touching the user's settings, an admin can use Gmail's **Routing**
page and the recipient address map — no verification needed, though changes
can take up to 24 hours.

**Microsoft 365 and Outlook** — Settings → Mail → Forwarding, turn on
**Enable forwarding**, and keep a copy. The catch: Microsoft blocks automatic
external forwarding unless an admin has allowed it. The default policy value,
**Automatic - System-controlled**, originally meant on, but Microsoft has
since changed it to mean off. When forwarding is blocked, the mail bounces
back to the original sender with error `5.7.520` — if a customer reports
that, have an admin set the anti-spam outbound policy's automatic forwarding
rules to **On - Forwarding is enabled** in the Defender portal. If you use inbox rules instead, pick
**Redirect**, not **Forward** — Forward rewrites the sender, so every
conversation would look like it came from you.

**Cloudflare Email Routing** — Add the UserJot address as a destination
address, click the verification email that lands in your inbox, then create a
routing rule pointing your support address at it. Only an option when your
domain's mail is actually routed through Cloudflare.

**Fastmail** — Settings → Filters & Rules → Create rule → **All messages** →
**Send a copy to**. No verification step; it works as soon as you save.

**Zoho Mail** — Settings → Mail Accounts → your address → Forwards. Zoho
sends a verification code instead of a link: copy it from the conversation in
your inbox and paste it into Zoho's Verify field.

## How replies work

When you reply from the dashboard, the customer gets a normal email from your
forwarding address, with your name in the From line. They just hit reply in
their mail client, and their response threads back into the same conversation.

Replies you send to a widget-started conversation also go out by email when
the customer has an address on file, so nobody misses an answer because they
closed the tab. Those come from UserJot's own `messages@` address rather than
your forwarding address, since the thread did not start over email.

## What gets filtered

UserJot quietly keeps junk out of the inbox. Auto-replies, out-of-office
messages, delivery failure notices, and obvious marketing blasts are either
skipped or held in the Spam view. Automated notifications like receipts are
delivered without waking Juno. The filter leans toward delivering when in
doubt, but it is a classifier, not a guarantee: a genuine customer email that
reads like a newsletter or list mail can occasionally land in Spam, so glance
at that view now and then.

## Pause or rename an address

Each address row has a menu with **Rename** and

**Pause receiving**. Renaming only changes the label,
never the address. Pausing stops new mail from entering Conversations while
keeping the address and all existing history; resume any time.

## Not the same as Email to Feedback

UserJot also has an **Email to Feedback** integration that turns forwarded
emails into feedback posts on your boards. That is a separate feature with a
separate address. Use email forwarding here when you want two-way support
conversations, and Email to Feedback when you want emails to become board
submissions.

## If mail is not showing up

Check the usual suspects: the forwarding address is paused, forwarding was
never finished on the mail provider side, or the message was an auto-reply
that got filtered. One more subtle case: manually forwarding a single email
makes you the sender, so the conversation starts with you rather than the
customer. Automatic forwarding preserves the original sender.

# Operators and availability

Source: https://userjot.com/support/operators-and-availability
Section: Conversations
Updated: 2026-10-06

> Set which teammates handle conversations, their working hours, and when your team shows as online, which decides what customers see in the chat.

Operators are the human face of your conversations. They power the team
avatars customers see in the widget and decide whether your workspace shows as
online. Any workspace owner or admin can be an operator.

Being an operator is not required to use the inbox. Every owner and admin can
read and reply either way. Operators are specifically about availability and
what customers see.

## Add an operator

1. Open **Settings**, go to

   **Conversations**, then
   **Operators**.

2. Select **Add operator** and pick an eligible
   workspace member. Only owners and admins qualify.

Adding an operator does not change their role or permissions. New operators
start with no availability configured, so set that up next.

## Set availability

Open an operator to configure when they count as available. There are two
ways, and they combine:

- **Available while using UserJot** makes them online whenever they are active
  in the dashboard, any time of day.
- **Follow a weekly schedule** makes them available during set hours in their
  timezone. The default is Monday through Friday, 9 AM to 5 PM. Use
  **Basic** for the same hours every day or
  **Advanced** for per-day hours.

Hours are personal, not a single workspace calendar. Each operator has their
own timezone and schedule.

**Appear offline now** overrides both. It is the switch to flip when someone
is signed in but should not count as available.

## What customers see

Customers see much less than you configure, on purpose:

- Up to four operator avatars — a photo, or initials when there is none — on
  the new-conversation screen. No names, titles, emails, or per-person status.
- A single workspace-level presence: a green **Online** dot when anyone is
  online or within hours, or a neutral "Team support" label otherwise. The
  widget never says "Offline."

If your plan includes **Mask public identities** and it is turned on,
customers see your workspace name and logo instead of operator faces.

## Remove an operator

The operator's page has a **Remove operator** action
under Danger zone. It stops them from counting toward availability. Their
workspace account is untouched.

# Away replies

Source: https://userjot.com/support/away-replies
Section: Conversations
Updated: 2026-10-06

> Set the automatic reply customers receive when nobody on the team is online, so they know when to expect an answer instead of waiting on a silent chat.

When a customer writes in and your whole team is away, UserJot sends a short
acknowledgment so the message does not feel like it fell into a void:

> We've notified the team — they'll reply as soon as they can.

That is the entire feature from the customer's side. This page covers when it
fires and when it stays quiet, because the rules are deliberately
conservative.

## When an away reply is sent

All of these need to be true:

- A customer sent a message (or Juno just handed the conversation to your
  team) and the conversation is waiting on you.
- Every operator has availability configured, and all of them are currently
  offline: outside their scheduled hours, not active in the app, or set to
  appear offline.
- Juno is not handling the conversation. When Juno is active, customers get a
  real answer instead of an away message.

The reply is sent once per waiting stretch, not once per message. If the
customer sends three messages while you are away, they get one acknowledgment.
After your team replies and the customer writes again during another away
stretch, they can get another.

## When it stays quiet

A few situations block away replies on purpose:

- Anyone on the team is within hours or actively using UserJot. One available
  operator means no away message.
- Any operator has no availability configured. UserJot cannot tell whether
  that person is away, so it says nothing — a single unconfigured operator
  keeps away replies off. If you want them, make sure every operator has
  either app presence or a schedule set up.
- The conversation is an automated email thread, like a receipt or system
  notification.

## The message is fixed

There is no away message editor right now. The wording above is what ships,
localized to the customer's language where supported. If you want to set
expectations in your own words, use the reply-time expectation on the

**Widget** settings page, which shows before a customer
even starts a conversation.

# Customize chat in the widget

Source: https://userjot.com/support/customize-chat-in-the-widget
Section: Conversations
Updated: 2026-09-16

> Control the greeting, visitor details, and reply-time expectations on the widget's Messages page.

Customers start conversations from the **Messages** page of your widget. The

**Widget** page under Conversations settings controls
what they see there: whether new conversations are open, what you ask of
anonymous visitors, the greeting, and the reply-time expectation.

Everything on this page stays editable even while new conversations are turned
off, so you can prepare before opening the doors.

## Allow new conversations

The master switch at the top. When it is off, customers cannot start new conversations, but
existing ones stay visible with their full history, and customers can still
reply to them. Use it to pause intake without hiding anything.

## Ask for visitor details

This applies only when an anonymous visitor starts a conversation. Users who
are signed in, or identified through your app, never see it.

Three modes:

- **Don't ask** lets visitors chat with no details.
- **Ask optionally** lets the first message go through, then asks for an
  email so the visitor can get replies when they leave. This prompt only
  appears when Email is among the fields you collect.
- **Require before sending** asks for the selected details before the first
  message can be sent.

You choose which fields to collect: **Email** lets the visitor receive
replies by email, and **Name** adds a display name to the conversation. These
details are self-declared, so they show as unverified in the dashboard.

## Greeting

The greeting appears above the message box when a customer starts a new
conversation. It is part of the screen, never a message in the thread.

Leave it empty to use the default, which reads "What can we help you with?" in
the widget. Custom greetings can run up to 240 characters and save when you
click away.

## Reply time

The reply expectation is a line of copy shown before a customer starts a
conversation, like "Typically replies in a few hours." It sets expectations
and nothing else: it does not change routing or your team's availability.

The options:

- **Automatic** calculates it from your recent reply history. It shows
  nothing until there is enough history to be honest: at least five first
  human replies over the last 30 days, spread across most of that period.
- **A few minutes**, **A few hours**, and **Within a day** are fixed choices.
- **Custom duration** takes anything from 5 minutes to 7 days.
- **Don't show** hides the line entirely.

Pick something you can actually hit. This line is a promise your team makes on
every new conversation.

# Conversation notifications

Source: https://userjot.com/support/conversation-notifications
Section: Conversations
Updated: 2026-10-06

> Set up browser push and email alerts for new conversations and customer replies, per operator, so nothing waits in the inbox unseen.

Conversations alert your team through browser push and email. They do not
appear in the in-app Activity feed, which stays dedicated to feedback events;
the Queue and Open counts in the Conversations sidebar section are your
in-dashboard signal instead.

## Set up browser push

Push is per browser, so each teammate enables it on each device they use:

1. Open the Activity bell in the dashboard sidebar, then select the gear to
   open **Notifications**.

2. Under **This device**, turn on

   **Browser notifications** and allow notifications
   when the browser asks.

3. Use **Send test notification** to confirm it
   works.

If the browser permission was denied at some point, the panel will tell you to
allow notifications in browser settings first.

## Choose what alerts you

The same panel has two conversation types, each available for push and email:

- **New conversations**, when a customer starts a conversation that needs your
  team.
- **Customer replies**, when a customer replies to a conversation that needs
  your team.

Both are on by default. Alerts go to workspace owners and admins.

## Notifications are quiet by design

A few behaviors keep alerts from piling up:

- While Juno is handling a conversation, nobody is notified. The first alert
  is Juno's handoff: the push notification is titled "AI handed off a
  conversation," and the email looks like a regular customer-reply
  notification.
- Push is skipped if you are already looking at the conversation or have
  already read the messages.
- Email waits a couple of minutes before sending, so if a teammate opens the
  thread first, the email never goes out.

## Reply straight from email

Team notification emails support reply-by-email: answer the email and your
response is sent to the customer as you, without opening the dashboard. Each
email also links to the conversation and to your notification settings.

# Block senders

Source: https://userjot.com/support/block-senders
Section: Conversations
Updated: 2026-10-06

> Block abusive or spammy senders so their messages never reach your conversations inbox, and manage the block list if you need to let someone back in.

When someone abuses your chat or support email, block them from their
conversation. Blocked senders cannot start new conversations or send replies,
but they can still read their existing conversations. Nothing about the block
is announced to them.

## Block someone

1. Open their conversation in the inbox.

2. Select **More actions** in the thread header, then

   **Block sender**.

3. Confirm in the dialog.

The block covers the identity behind the conversation: their visitor session,
their member account if they have one, and their email address if one is on
file. Re-blocking the same person from another conversation extends the same
block rather than creating a duplicate.

Blocking is separate from spam. **Mark as spam** files one conversation away;
**Block sender** stops the person from writing at all. Use both together when
it fits.

## What a blocked sender experiences

- In the widget, their messages fail to send with a generic error. Their
  history stays readable.
- Email they send is dropped quietly. There is no bounce, so nothing confirms
  to them that they are blocked.

## Manage the block list

The list lives under **Settings** →

**Conversations** →
**Moderation**.

**Blocked senders** shows everyone you have blocked and when. Each row has

**View conversation** to see the thread that led to the
block, and **Unblock**, which also shows who placed the
block.

**Blocked IP addresses** is a separate list of address-level rules. IP rules
expire on their own after 30 days and disappear from the list when they do.

## Unblock

Unblocking takes effect immediately: the person can start conversations and
reply again. Unblocking a sender releases every handle in that block, but it
does not lift a separate IP rule, and unblocking an IP does not lift a sender
block. Check both lists if someone should be fully restored.

# Meet Juno

Source: https://userjot.com/support/meet-juno
Section: Juno
Updated: 2026-10-06

> Meet Juno, the AI operator that answers conversations first from your docs, stays quiet when it should, and hands off to your team in the same thread.

Juno is the AI operator built into Conversations. When it is active, it picks
up new conversations as they arrive, answers questions from the knowledge you
give it, and hands the thread to your team when a human is needed.

Customers see Juno as Juno: it has its own name and a distinct avatar, so it
is never mistaken for a teammate.

## Turn Juno on

1. Open **Settings**, go to

   **Conversations**, then
   **Juno AI**.

2. Flip the **Active** toggle.

While active, Juno picks up new conversations as they arrive. Turning it off
sends new conversations to your team instead, but Juno keeps handling the
conversations it already has.

Before turning it on, give Juno something to work with. It only answers from
the knowledge you publish, so an empty knowledge base means Juno hands almost
everything to your team.

## Shape how Juno sounds

The **Behavior** section controls Juno's voice:

- **Tone**: Warm & Helpful, Professional, Direct, Empathetic, or Playful.
- **Reply length**: Auto stays brief in chat and balanced in email. Or pin it
  to Brief, Balanced, or Detailed.
- **Formality**: Auto matches the customer, or choose Casual, Neutral, or
  Formal.
- **Emoji**: None, Some, or Lots.

Juno replies in the customer's language automatically.

## When Juno answers and when it does not

Juno answers greetings, product questions covered by your knowledge, and
requests it can help with directly. It stays silent on spam, empty messages,
and automated mail like receipts, so your inbox does not fill with bot-to-bot
chatter.

When Juno cannot help, it hands off rather than guessing. That happens when
the customer asks for a human, when your knowledge does not cover the
question, when it is not confident, or when the topic needs a person, like
account or billing disputes. The customer sees a short note that a teammate is
taking over, and the conversation lands in your Queue.

Once a human replies in a thread, Juno steps back and stays back. If you want
it to take over again, use **Hand to Juno** in the
thread header.

## Auto-resolve

If Juno fully answers and the customer goes quiet, the conversation resolves
on its own: after 30 minutes of silence in chat, or 72 hours for email. Any
customer reply reopens it. Conversations your team has touched are never
auto-resolved.

## What Juno will not do

Juno cannot change your product, settings, billing, or customer data, and it
does not invent answers that are not in your knowledge. It also never files
feedback requests without the customer confirming first.

## The activity meter

The top of the Juno page shows **Handled by Juno** for the last 30 days: every
conversation Juno picked up, whether it resolved the thread or handed it to
your team, and what share resolved without your team stepping in.

# Teach Juno your product

Source: https://userjot.com/support/teach-juno
Section: Juno
Updated: 2026-10-06

> Build the knowledge base Juno answers from: upload files, crawl your docs and website, and review what she has learned so her answers stay accurate.

Juno only answers from knowledge you give it. That is a feature: it means Juno
never improvises pricing, limits, or instructions. This page is where you
build that knowledge.

Find it under **Settings** →

**Conversations** →**Juno AI**
→**Manage knowledge**.

## Add a source

Select **Add source** and pick one of two kinds:

- **Upload file** takes Markdown, plain text, HTML, JSON, or YAML, up to
  10 MB. Good for internal FAQs, policies, or docs that are not public.
- **Crawl website** takes a URL and reads that page plus the public pages
  beneath it. Crawls stay within the path you give: crawling
  `docs.example.com` covers your docs, not your blog or homepage.

During the beta, a workspace can have up to 5 sources.

## Publishing: when Juno actually starts using it

Adding a source does not change Juno's answers instantly. Sources are
processed and then published as one package, and the page shows where things
stand: **Updating Juno…** while a new version processes, then **Knowledge is
live** when Juno is answering from it.

While an update is in flight, Juno keeps using the current version. Nothing
breaks mid-conversation.

## Keep sources current

Each source has a menu for maintenance:

- **Replace file…** uploads a new version of a file.
  Juno keeps using the old one until the update finishes.
- **Recrawl** refreshes a website source.
- **Pause** takes a source out of Juno's knowledge
  without deleting it. Like any change, it queues an update, and Juno keeps
  answering from the current version until the new one is live.
- **Remove website…** or
  **Remove file…** deletes the source for good.

## Coming soon: your UserJot content

The **From UserJot** section lists your changelog and completed feedback as
future sources that will connect automatically. They are visible on the page
but not feeding Juno yet.

## If Juno does not know something

When a customer asks something outside the knowledge base, Juno hands the
conversation to your team instead of guessing. If you see the same handoff
topic repeatedly, that is your signal to add a source covering it.

# Juno and feedback requests

Source: https://userjot.com/support/juno-feedback-requests
Section: Juno
Updated: 2026-10-06

> When a customer asks for a feature in chat, Juno finds or files the request on your board and adds their vote, after the customer confirms.

Conversations feed the same feedback loop as your boards. When a customer
mentions a feature idea or a problem in chat, Juno can search your public
boards for an existing request, show it to the customer, and file, vote, or
follow on their behalf.

The important part: Juno always asks first. It shows the customer a card with
the request, and only acts after the customer confirms in their next message.
Nothing is filed silently.

## Turn it on or off

The switch lives under **Settings** →

**Conversations** →**Juno AI**
, in the **Capabilities** section, labeled **Feedback requests**. It is on by
default.

## What the customer experiences

A typical flow in the widget:

1. The customer describes something they want.
2. Juno searches your public boards. If a matching request exists, it shows a
   card for it; if not, it drafts a new one and shows that.
3. The customer says yes, and Juno posts the request, adds their vote, or
   follows the existing one. The card updates to show what happened, and the
   customer can open the request right inside the widget.

If your workspace has moderation on, requests Juno files go through the same
review queue as any other submission. The card reads **Posted · Pending
review** and cannot be opened until the request is public.

See [moderate content](https://userjot.com/support/moderate-content) for how your team reviews
requests and chooses whether to publish them.

## Who can do what

Signed-in and identified users get the full flow: create, vote, and follow.
Anonymous visitors can have Juno create a request only if guest posting is
enabled for your workspace, and they cannot vote or follow, same as guests
everywhere else in UserJot.

This works in widget chat only. Email conversations do not get feedback
cards.

## Limits

To keep boards clean, Juno files at most 3 new requests per conversation and
25 per workspace per day, plus 10 votes and follows combined per
conversation.

## Where you see the links

In the dashboard, linked requests appear in the conversation's details panel
under **Linked requests**, each labeled **Filed**, **Shown**, **Voted**, or
**Following**. Linking happens through Juno during the conversation; there
is no separate attach control in the inbox.

# Manage your plan

Source: https://userjot.com/support/manage-plan
Section: Billing & Account
Updated: 2026-10-06

> Review your UserJot workspace plan, update billing details, download invoices, check current usage against limits, and change or cancel your plan.

You can manage your workspace plan from the billing settings page.

## Open billing settings

1. Open **Settings** in your workspace.
2. Go to **Billing**.
3. Review your current plan and available billing actions.

## What you can manage

From the billing page, you can:

- see your current plan
- start a free trial if your workspace is eligible
- upgrade or change your plan
- switch from monthly to yearly billing
- open invoices and payment methods
- cancel or resume an active paid plan

Workspace owners and admins can manage all of these billing actions.

If you are on a paid plan, invoices and payment methods open in the billing
portal.

## How plan limits work

Your workspace plan controls which features and limits are available.

This includes things like board limits, tag limits, team member limits,
integrations, and whether features such as guest access, private boards,
moderation, custom branding, or SSO are available.

When a feature is not included in your current plan, UserJot will usually show
an upgrade prompt at the point where you try to use it.

## Free and paid plans

Free workspaces can view their current plan and upgrade when needed.

Paid workspaces can also manage billing details, payment methods, renewal
timing, cancellation, and plan changes from the billing page.

# Member roles

Source: https://userjot.com/support/member-roles
Section: Billing & Account
Updated: 2026-10-06

> What owners, admins, and members can each do in a workspace, how to invite teammates and change roles, and how admin seats count on each plan.

UserJot uses a small set of roles to control who can manage the workspace and
who can simply participate in feedback.

## Understand the roles

- **Owner** has the highest level of access. Owners are the only people who can
  remove another privileged team member. An owner cannot be removed from the
  workspace through team settings.
- **Admin** can help run the workspace day to day. Admins can manage feedback,
  boards, tags, changelog work, integrations, and team settings. They can also
  manage billing and plan changes.
- **Member** is a regular user role for people who participate in the product
  experience. Members can submit feedback, vote, comment, and follow requests,
  but they do not get admin access to workspace settings.

## Manage your internal team

1. Open **Settings** in your workspace.
2. Go to **Team**.
3. Review the current privileged team members listed there.
4. Invite another teammate if you want them to help manage the workspace.

## What team settings are for

Team settings are focused on your internal team.

That means this area is mainly where you manage owners and admins, update their
titles, and review outstanding invitations. It is not the main place where
regular product users are managed.

## A few practical rules

- New team invites are created as admin invites.
- Admins and owners can view the team area and invite more admins.
- Only owners can remove another privileged member.
- Owners and admins can manage the plan, including trials, upgrades, and
  cancellation.

# Notification preferences

Source: https://userjot.com/support/notification-preferences
Section: Billing & Account
Updated: 2026-09-16

> Choose how you are notified about feedback, comments, and conversations.

Notification preferences let each workspace member choose how they hear about
activity. You can control the in-app activity feed, browser push
notifications, and conversation emails from one panel. These settings only
affect your own account.

## Open notification preferences

1. Open your workspace dashboard.
2. Select the activity bell in the sidebar.
3. Select the gear icon in the activity popover. The panel switches to
   **Notifications**.
4. Turn each notification type on or off.

## This device

The **This device** section controls whether the browser you are currently
using can show notifications at all.

Turn on **Browser notifications** to let this browser
deliver conversation alerts. Once it is enabled, you can use

**Send test notification** to confirm it works. If your
browser is blocking notifications, allow them in the browser settings first,
then come back and try again.

## In-app notifications

The **In-app** section controls what appears in your dashboard activity feed
and unread count. You can toggle:

- **New feedback**, when someone submits feedback to the workspace
- **Comments on feedback** you are following
- **Reactions on feedback** you are following
- **Replies to your comments**
- **Reactions on your comments**

The new feedback option is available to workspace owners and admins. Other
members see the types related to feedback and comment activity they are
connected to.

When you turn off an in-app type, UserJot hides that type from your activity
feed and unread count. New matching activity will not create in-app
notifications for you, and existing unread activity of that type is marked as
read when the preference is saved. All types are on by default.

## Push and email notifications

The **Push** and **Email** sections control conversation alerts, and each
channel is toggled independently:

- **New conversations**, when a customer starts a conversation that needs your
  team
- **Customer replies**, when a customer replies to a conversation

Push notifications also require **Browser notifications** to be on for the
device that should receive them.

## What does not change

These preferences do not control the emails UserJot sends to your users.
Subscriber emails, weekly digests, and changelog announcements are managed
separately and are not affected by this panel.

# A/B Testing

Source: https://userjot.com/definitions/a-b-testing
Updated: 2025-01-28

> A/B testing shows two versions of a page or feature to randomly split users and measures which one converts better, so decisions rest on data, not opinion.

A/B Testing involves creating two versions of a product or feature, often referred to as Version A and Version B. These versions differ in one or more aspects, such as design, content, or functionality. The goal is to see which version leads to better outcomes, such as higher engagement, increased conversions, or improved user satisfaction.

To conduct A/B Testing, businesses randomly assign users to either Version A or Version B. They then collect data on how users interact with each version over a set period. This data can include metrics like click-through rates, conversion rates, time spent on the page, and user feedback.

Once the testing period is over, the data is analyzed to determine which version performed better. If Version B shows a significant improvement over Version A, the business might decide to implement Version B permanently. If the results are inconclusive, further testing or adjustments may be needed.

A/B Testing is widely used in various industries, including e-commerce, marketing, and software development. It allows businesses to make incremental improvements to their products and services based on real user behavior. By testing different variations, businesses can optimize their offerings and enhance the user experience.

One of the key benefits of A/B Testing is its ability to provide concrete, data-driven insights. Instead of relying on assumptions or opinions, businesses can use A/B Testing to make informed decisions about what works best for their users. This approach can lead to more effective products and higher customer satisfaction.

However, A/B Testing also has some challenges. It requires a sufficient sample size to produce statistically significant results, which can take time and resources. Additionally, businesses need to ensure that the test is set up correctly and that the results are interpreted accurately to avoid drawing incorrect conclusions.

In summary, A/B Testing is a valuable tool for businesses looking to improve their products and services. By comparing different versions and analyzing user data, businesses can make data-driven decisions that lead to better outcomes. While it requires careful planning and execution, A/B Testing can help businesses optimize their offerings and meet user needs more effectively.

# AARRR Framework

Source: https://userjot.com/definitions/aarrr-framework
Updated: 2025-01-28

> The AARRR framework, or Pirate Metrics, tracks a product's growth in five stages: Acquisition, Activation, Retention, Referral, and Revenue.

The AARRR Framework helps companies understand and improve their customer journey. The first stage, Acquisition, involves attracting new users to the product or service. This can be done through various marketing channels like social media, search engine optimization, or paid advertising. The goal is to bring in as many potential customers as possible.

Once users are acquired, the next step is Activation. This stage is about turning new visitors into engaged users. Activation focuses on the first user experience, ensuring that new users find value in the product quickly. For example, a SaaS company might consider a user activated when they complete a key action, like signing up for a trial or using a core feature.

Retention is the third stage and is crucial for long-term success. It involves keeping users engaged over time. Companies need to provide ongoing value to ensure users return to the product. This can be achieved through regular updates, personalized content, or excellent customer support. High retention rates indicate that users find the product useful and are likely to continue using it.

The fourth stage, Referral, focuses on encouraging existing users to recommend the product to others. This can be facilitated through referral programs, incentives, or simply by providing a great user experience that users want to share. Referral is important because it can lead to organic growth and lower customer acquisition costs.

The final stage, Revenue, is about converting users into paying customers. This can be done through various monetization strategies, such as subscriptions, one-time purchases, or in-app purchases. The goal is to ensure that the product generates enough revenue to sustain and grow the business.

To implement the AARRR Framework effectively, companies should track metrics at each stage. This involves setting up analytics to measure key performance indicators like the number of new users, activation rates, retention rates, referral rates, and revenue. By analyzing these metrics, companies can identify areas for improvement and optimize their growth strategies.

For example, if a company notices a low activation rate, it might need to improve its onboarding process. If retention is low, the company might need to focus on adding more value for existing users. By continuously monitoring and optimizing each stage of the AARRR Framework, companies can drive sustainable growth and achieve their business goals.

# Agile Methodology

Source: https://userjot.com/definitions/agile-methodology
Updated: 2025-01-21

> Agile is an approach to building software in short iterations called sprints, with working output at the end of each and feedback shaping the next.

Agile methodologies are characterized by breaking down large projects into smaller, manageable iterations called sprints. These sprints typically last for a short period of time, such as one to four weeks. At the end of each sprint, the team delivers a working piece of software or a specific set of features. This iterative approach allows for continuous feedback and adjustments, ensuring that the product aligns with the evolving needs of the customer.

One core principle of agile is the importance of collaboration. Agile teams are typically cross-functional, bringing together developers, testers, designers, and product owners. This close collaboration helps to foster a shared understanding of the project goals and enables faster decision-making. Regular communication and face-to-face interactions are key components of agile practices.

Customer feedback is another critical element of agile. Agile teams regularly seek input from the customer or end-users throughout the development process. This feedback is used to validate assumptions, make necessary adjustments, and ensure that the product meets the customer's expectations. This iterative feedback loop helps to reduce the risk of building a product that does not meet the needs of the market.

Agile methodologies also emphasize the importance of adapting to change. Unlike traditional methods that follow a rigid plan, agile embraces change as a natural part of the development process. Agile teams are prepared to adjust their plans and priorities based on new information or feedback. This adaptability helps to ensure that the product remains relevant and valuable in a constantly changing environment.

Several specific frameworks fall under the umbrella of agile, including Scrum and Kanban. Scrum is a structured framework that defines specific roles, events, and artifacts. Kanban is a more flexible framework that focuses on visualizing the workflow and limiting work in progress. Both frameworks share the core values of agile but offer different approaches to implementation.

In summary, agile methodology provides a way to manage projects with flexibility and responsiveness. By emphasizing iterative development, collaboration, customer feedback, and adaptability, agile teams can deliver value more quickly and effectively. This approach helps to ensure that the final product meets the needs of the customer and remains competitive in the market.

# Annual Recurring Revenue (ARR)

Source: https://userjot.com/definitions/annual-recurring-revenue-arr
Updated: 2025-01-21

> Annual Recurring Revenue (ARR) is the yearly value of a subscription business's recurring contracts, usually MRR × 12, excluding one-time fees.

ARR is calculated by multiplying the monthly recurring revenue (MRR) by twelve. This calculation provides a yearly projection of the revenue that is expected to be generated from existing customers. It’s important to note that ARR typically excludes one-time fees, setup costs, and other non-recurring revenue sources. By focusing on recurring revenue, ARR offers a stable and predictable view of a company’s financial performance.

Tracking ARR allows businesses to evaluate their growth rate and identify trends in their customer base. An increasing ARR indicates that the business is acquiring new customers and/or retaining existing ones. Conversely, a declining ARR might signal that the company is losing customers or experiencing a reduction in subscription values. Therefore, monitoring ARR is vital for understanding the overall health of a subscription-based business.

ARR is also a useful metric for forecasting future revenue and making informed business decisions. By analyzing ARR trends, companies can project their future income and plan for investments, hiring, and other strategic initiatives. This predictability makes ARR a valuable tool for financial planning and resource allocation.

In addition, ARR is a key metric for investors and stakeholders. It provides insight into the long-term sustainability and growth potential of a business. Investors often use ARR to compare the performance of different companies in the same industry and to assess the value of a subscription-based business. Therefore, understanding and effectively managing ARR is crucial for attracting investment and ensuring the long-term success of a company.

# Backlog

Source: https://userjot.com/definitions/backlog
Updated: 2025-01-24

> A backlog is the prioritized list of user stories, bugs, and technical tasks a product team plans to work on, ordered so the most important come first.

In product management, a backlog is essential for organizing and planning work. It typically contains user stories, bug fixes, technical tasks, and other items that contribute to the development of a product. Each item in the backlog is prioritized based on its importance and urgency, allowing the team to focus on the most critical tasks first.

Maintaining a backlog involves regular review and refinement. Product managers and teams should periodically assess the items in the backlog to ensure they remain relevant and aligned with the project's goals. This process, known as backlog grooming, helps to keep the list up-to-date and focused on delivering value to the customer.

A well-managed backlog provides several benefits. It helps to clarify the scope of the project, making it easier for teams to understand what needs to be done and in what order. It also facilitates communication with stakeholders by providing a clear view of the project's progress and future plans. Additionally, a backlog can help to identify dependencies and potential bottlenecks, allowing teams to plan their work more effectively.

Backlogs can be used in various project management methodologies, including agile and waterfall. In agile frameworks like Scrum, the backlog is a key component of the sprint planning process. The team selects items from the backlog to work on during each sprint, ensuring that the most important tasks are addressed first. In waterfall projects, the backlog can serve as a tool for tracking and managing tasks throughout the project lifecycle.

In summary, a backlog is a vital tool for product managers and development teams. By maintaining a prioritized list of tasks and features, teams can ensure that their work is organized, focused, and aligned with the project's goals. Regular review and refinement of the backlog help to keep the project on track and deliver value to the customer.

# Backlog Grooming

Source: https://userjot.com/definitions/backlog-grooming
Updated: 2025-01-28

> Backlog grooming, or refinement, is the recurring session where a team reviews backlog items, clarifies them, estimates effort, and reorders by priority.

Backlog Grooming involves regularly examining the product backlog, which is a list of all the tasks, features, and requirements that need to be addressed in a project. The goal is to keep the backlog up-to-date and organized, ensuring that it reflects the current needs and priorities of the project.

During Backlog Grooming sessions, team members review each item in the backlog. They discuss the details of each task, estimate the effort required, and determine its priority. This process helps to clarify the scope of work and identify any dependencies or potential roadblocks.

One key aspect of Backlog Grooming is breaking down large tasks into smaller, more manageable pieces. This makes it easier for the team to plan and execute the work, as well as to track progress more effectively. By breaking down tasks, teams can also identify any gaps or missing information that need to be addressed.

Another important part of Backlog Grooming is prioritizing the tasks in the backlog. Teams need to decide which items are most important and should be tackled first. This often involves considering factors such as business value, customer needs, and technical feasibility. By prioritizing tasks, teams can ensure that they are working on the most impactful items first.

Backlog Grooming also involves removing or updating items that are no longer relevant. As projects evolve, some tasks may become obsolete or less important. Regularly reviewing the backlog helps to keep it clean and focused, preventing it from becoming cluttered with outdated or unnecessary items.

To conduct effective Backlog Grooming, teams should schedule regular sessions, typically on a weekly or bi-weekly basis. These sessions should involve key stakeholders, including product owners, developers, and other team members who can provide valuable insights and feedback.

In summary, Backlog Grooming is an essential practice for maintaining a clear and prioritized product backlog. By regularly reviewing and refining the backlog, teams can ensure that they are working on the most important tasks and delivering value to their customers. Effective Backlog Grooming leads to a more efficient and productive development process.

# Billing Cycle

Source: https://userjot.com/definitions/billing-cycle
Updated: 2025-01-21

> A billing cycle is the recurring period between invoices, usually monthly, quarterly, or annual, that sets when a customer is charged and payment is due.

Billing cycles can vary, but they are often monthly, quarterly, or annual. The specific length of a billing cycle is determined by the service provider and is usually stated in the terms of service. For example, a subscription service might have a monthly billing cycle, while an annual software license might have a yearly one.

For businesses, billing cycles are a key part of revenue management. They determine when revenue is recognized and when payments are expected. Businesses need to track billing cycles carefully to manage cash flow and ensure timely payments from customers.

For customers, understanding billing cycles helps in managing personal finances. Knowing when a payment is due allows customers to budget accordingly and avoid late fees or service disruptions. It also helps customers track their expenses and understand their spending patterns.

Billing cycles also affect how services are used. Some services might have usage limits within a billing cycle, and exceeding these limits can result in extra charges. Customers need to be aware of these limits and plan their usage accordingly to avoid unexpected costs.

Invoices are typically generated at the end of a billing cycle, detailing the charges for that period. These invoices are sent to customers, outlining the amount due and the payment deadline. Customers should review these invoices carefully to ensure accuracy and address any discrepancies promptly.

Overall, billing cycles are a fundamental part of the business-customer relationship. They set the schedule for payments and define the timeframe for service usage. Understanding billing cycles helps both businesses manage revenue and customers manage their finances.

# Bounce Rate

Source: https://userjot.com/definitions/bounce-rate
Updated: 2025-01-28

> Bounce rate is the share of sessions where a visitor viewed one page and left: single-page sessions ÷ total sessions × 100. High values flag weak pages.

Bounce Rate is calculated by dividing the number of single-page sessions by the total number of sessions on a website, then multiplying by 100 to get a percentage. A high bounce rate can indicate that visitors are not finding what they are looking for or that the website is not engaging enough to encourage further exploration.

For businesses, understanding Bounce Rate is crucial for improving website performance. A high bounce rate might suggest that the landing page is not relevant to the visitor's expectations or that the page loads too slowly. By analyzing the bounce rate, businesses can identify areas for improvement, such as optimizing page content, improving site speed, or enhancing the user experience.

To reduce Bounce Rate, businesses can implement several strategies. First, they should ensure that the content on the landing page is relevant and engaging. This can be achieved by aligning the page content with the keywords and ads that brought visitors to the site. Second, improving site navigation and providing clear calls to action can encourage visitors to explore more pages. Finally, optimizing the site for mobile devices can help retain visitors who access the site from smartphones or tablets.

Monitoring Bounce Rate over time allows businesses to track the impact of changes made to the website. By comparing bounce rates before and after implementing improvements, businesses can assess the effectiveness of their efforts and make data-driven decisions to enhance user engagement.

In summary, Bounce Rate is an important metric for understanding user behavior and website performance. By analyzing and acting on Bounce Rate data, businesses can improve their website's effectiveness, increase user engagement, and ultimately achieve their business goals.

# Chargeback

Source: https://userjot.com/definitions/chargeback
Updated: 2025-01-28

> A chargeback is a forced refund started when a customer disputes a card charge with their bank, which reverses the payment while the claim is investigated.

A chargeback typically begins when a customer contacts their bank or credit card issuer to dispute a charge on their account. The reasons for initiating a chargeback can vary, including unauthorized transactions, dissatisfaction with a product or service, or billing errors. Once the customer files a dispute, the bank or issuer investigates the claim and may temporarily reverse the transaction, placing the funds back into the customer's account.

The next step involves the bank or issuer notifying the merchant about the chargeback. The merchant then has the opportunity to respond to the dispute by providing evidence that the transaction was legitimate and that the product or service was delivered as agreed. This evidence can include receipts, delivery confirmations, and communication records with the customer.

If the merchant successfully disputes the chargeback, the funds may be returned to their account. However, if the bank or issuer rules in favor of the customer, the merchant loses the transaction amount and may also incur additional fees. These fees can add up, making chargebacks a significant concern for businesses, especially those with high volumes of transactions.

To manage chargebacks effectively, businesses can implement several strategies. First, they should ensure clear communication with customers about their products, services, and billing practices. Providing detailed receipts and maintaining records of customer interactions can help in the event of a dispute. Second, businesses can use fraud detection tools to identify and prevent unauthorized transactions before they result in chargebacks. Finally, having a responsive customer service team can help resolve issues before they escalate to chargebacks.

In summary, a chargeback is a critical process for protecting consumers, but it also presents challenges for businesses. By understanding the chargeback process and implementing effective prevention and management strategies, businesses can minimize their impact and maintain a healthy financial operation.

# Click Through Rate

Source: https://userjot.com/definitions/click-through-rate
Updated: 2025-01-28

> Click-through rate (CTR) is clicks ÷ impressions × 100: the share of people who saw an ad, link, or listing and clicked. 1,000 views and 10 clicks is 1%.

Click Through Rate is calculated by dividing the number of clicks by the number of impressions and then multiplying by 100 to express it as a percentage. For example, if an ad receives 1000 impressions and 10 clicks, the CTR would be 1%.

Tracking the Click Through Rate helps businesses understand how engaging their ads or links are to their target audience. A high CTR indicates that the ad or link is relevant and compelling to viewers, while a low CTR might suggest that the content needs improvement. By analyzing the CTR, businesses can make data-driven decisions to optimize their digital marketing strategies.

To improve the Click Through Rate, businesses can focus on several areas. First, they should ensure that their ad copy and visuals are appealing and relevant to the target audience. Second, using clear and compelling calls-to-action can encourage more clicks. Third, targeting the right audience through precise ad placement and keywords can increase the likelihood of clicks. Regularly testing different ad variations can also help identify what works best and lead to higher CTRs.

It's important for businesses to segment their Click Through Rate data to gain more insights. By analyzing CTRs for different ad formats, placements, or demographics, businesses can tailor their strategies to better meet the needs of specific groups. For example, if certain demographics show a higher CTR, the business might focus more on targeting those groups.

In summary, Click Through Rate is a key metric for evaluating the performance of online ads and links. By understanding and optimizing the Click Through Rate, businesses can enhance their digital marketing efforts, improve engagement, and ultimately drive more traffic to their websites or apps.

# Conversion Rate

Source: https://userjot.com/definitions/conversion-rate
Updated: 2025-01-28

> Conversion rate is the percentage of visitors who complete a desired action, such as signing up or buying: conversions ÷ visitors × 100. 50 of 1,000 is 5%.

Conversion Rate is calculated by dividing the number of conversions by the total number of visitors and then multiplying by 100 to express it as a percentage. For example, if a website has 1000 visitors and 50 of them complete a purchase, the conversion rate would be 5%.

Tracking the Conversion Rate helps businesses understand how well their website or app is performing in terms of turning visitors into customers. A low conversion rate might indicate issues with the user experience, pricing, or the effectiveness of marketing campaigns. By analyzing the Conversion Rate, businesses can identify areas for improvement and make data-driven decisions to optimize their conversion funnel.

To improve the Conversion Rate, businesses can take several steps. First, they should ensure that their website or app is user-friendly and easy to navigate. Second, clear calls-to-action and compelling content can encourage visitors to take the desired action. Third, offering promotions or incentives can motivate visitors to convert. Regularly testing and optimizing different elements of the site or app can also lead to higher conversion rates.

It's important for businesses to segment their Conversion Rate data to gain more insights. By analyzing conversion rates for different traffic sources, devices, or user demographics, businesses can tailor their strategies to better meet the needs of specific groups. For example, if mobile users have a lower conversion rate, the business might need to optimize the mobile experience to improve conversions.

In summary, Conversion Rate is a critical metric for assessing the performance of a website or app. By understanding and optimizing the Conversion Rate, businesses can improve their marketing and sales efforts, enhance the user experience, and ultimately increase their revenue.

# Customer Acquisition Cost

Source: https://userjot.com/definitions/customer-acquisition-cost
Updated: 2025-01-28

> Customer Acquisition Cost (CAC) is the total sales and marketing spend divided by the number of new customers it brought in during the same period.

Customer Acquisition Cost is calculated by dividing the total costs of sales and marketing over a specific period by the number of new customers acquired during that same period. These costs can include advertising expenses, salaries of sales and marketing teams, the cost of promotional materials, and any other expenses directly related to acquiring new customers.

Understanding CAC is crucial for businesses as it directly impacts profitability. A high CAC indicates that a company is spending a lot to gain each new customer, which can be unsustainable if the lifetime value of those customers does not exceed the acquisition cost. Conversely, a low CAC suggests that the company is efficiently attracting new customers, which can lead to higher profits.

To manage CAC effectively, businesses need to track and analyze their sales and marketing efforts. This involves monitoring which channels and campaigns are most effective at bringing in new customers and at what cost. By identifying the most cost-effective methods, companies can optimize their spending and improve their CAC.

Businesses can also work on reducing their CAC by improving their sales and marketing strategies. This might include refining target audiences, enhancing the customer experience, or leveraging more cost-effective marketing channels. Additionally, increasing customer retention can help lower the overall CAC, as retaining existing customers is often less expensive than acquiring new ones.

In summary, Customer Acquisition Cost is a vital metric for businesses to monitor. By understanding and managing CAC, companies can make strategic decisions that enhance their growth and profitability. Regular analysis and optimization of sales and marketing efforts are essential for maintaining a healthy CAC and ensuring long-term business success.

# Customer Churn Rate

Source: https://userjot.com/definitions/customer-churn-rate
Updated: 2025-01-28

> Customer churn rate is the percentage of customers who cancel or stop using a product in a given period, measured against the customers you started with.

Customer Churn Rate is calculated by dividing the number of customers lost during a period by the total number of customers at the start of that period. This figure is then multiplied by 100 to express it as a percentage. For example, if a company starts with 1000 customers and loses 50 over a month, the churn rate for that month would be 5%.

Monitoring the Customer Churn Rate helps businesses identify trends and issues that may lead to customer dissatisfaction. A high churn rate can indicate problems with the product or service, poor customer support, or competitive pressures. By understanding the reasons behind customer churn, companies can take steps to improve their offerings and retain more customers.

To reduce the Customer Churn Rate, businesses can implement several strategies. First, they should focus on providing excellent customer service, addressing customer concerns promptly and effectively. Second, offering incentives or loyalty programs can encourage customers to stay with the company. Third, regularly collecting and acting on customer feedback can help businesses make necessary improvements to their products or services.

It's also important for businesses to segment their customer base and analyze churn rates for different groups. This can reveal which types of customers are more likely to leave and why, allowing for targeted retention efforts. For example, if a particular customer segment has a higher churn rate, the company might need to tailor its marketing or support strategies to better meet the needs of that group.

In summary, Customer Churn Rate is a critical metric for assessing customer retention and loyalty. By understanding and managing churn, businesses can improve their customer relationships, enhance their products or services, and ultimately increase their long-term success.

# Customer Journey Map

Source: https://userjot.com/definitions/customer-journey-map
Updated: 2025-01-28

> A customer journey map is a diagram of every step a customer takes with a product, from first hearing of it through purchase and after, pain points marked.

A Customer Journey Map starts with identifying the different stages a customer goes through when interacting with a business. These stages typically include awareness, consideration, purchase, retention, and advocacy. By mapping out these stages, businesses can see the entire customer experience from start to finish.

The first step in creating a Customer Journey Map is to gather data about customer interactions. This can include surveys, customer feedback, and analytics data. The goal is to understand how customers move through the different stages and what their experiences are like at each point.

Once the data is collected, the next step is to create the visual map. This involves plotting out the customer journey on a timeline or flowchart, showing the different touchpoints where customers interact with the business. Each touchpoint is analyzed to identify pain points, opportunities for improvement, and moments of delight.

The Customer Journey Map also includes information about customer emotions and thoughts at each stage. This helps businesses understand the customer's perspective and identify areas where they can enhance the experience. For example, if customers feel frustrated during the purchase process, the business can take steps to make it easier and more enjoyable.

Another important aspect of the Customer Journey Map is identifying the different customer personas. Not all customers have the same needs or experiences, so it's important to create separate maps for different segments of the customer base. This allows businesses to tailor their strategies to meet the specific needs of each group.

Once the Customer Journey Map is complete, businesses can use it to make informed decisions about how to improve the customer experience. This might involve redesigning certain touchpoints, improving customer service, or introducing new features or services. The map serves as a guide for ongoing improvements and helps businesses stay focused on the customer's needs.

In summary, a Customer Journey Map is a valuable tool for understanding and improving the customer experience. By visually representing the customer's journey, businesses can identify areas for improvement and make data-driven decisions to enhance their products and services.

# Customer Retention Metrics

Source: https://userjot.com/definitions/customer-retention-metrics
Updated: 2025-01-28

> Customer retention metrics are the KPIs that show how well a business keeps customers over time: churn rate, repeat purchase rate, lifetime value, and NRR.

Keeping customers is fundamental for any business that relies on ongoing relationships, like Software as a Service (SaaS) companies. Instead of focusing only on attracting new users, successful businesses pay close attention to keeping the ones they already have. This involves understanding and tracking specific **customer retention metrics**. These **measures of customer retention** give you insight into how loyal your customers are and how effectively your business delivers lasting value.

## What is Customer Retention?

In the context of subscription-based businesses like SaaS, customer retention means consistently keeping paying customers who actively use your product over the long term. It's more than just preventing cancellations. It involves building strong relationships, encouraging customers to use your product fully, and finding ways to increase the value they get (and the revenue they generate). Good retention shows that customers find ongoing value in your service and choose to stay rather than look elsewhere. It’s about turning initial sign-ups into loyal, long-term users.

## Why Measuring Customer Retention Matters

Tracking **customer retention metrics** is vital for stable growth, especially for SaaS startups. Here’s why:

1.  **Predictable Revenue:** Retained customers provide a steady stream of recurring income. This predictability helps with financial planning and making informed decisions about future investments.
2.  **Cost Efficiency:** Keeping an existing customer typically costs much less than acquiring a new one – studies suggest it can be 5 to 25 times cheaper. Focusing on retention lowers your overall Customer Acquisition Cost (CAC).
3.  **Revenue Growth:** Happy, long-term customers are more likely to upgrade their plans or add new features (upselling and cross-selling). This growth from your existing customer base is often more profitable than finding new customers.
4.  **Increased Customer Lifetime Value (CLTV):** Customers who stay longer contribute more revenue over their entire relationship with your business. A higher CLTV means each customer is more valuable in the long run.
5.  **Referrals:** Satisfied customers often recommend your product to others. This word-of-mouth marketing is powerful and cost-effective. A small increase in retention can lead to a significant jump in profits.
6.  **Product-Market Fit Validation:** High retention rates indicate that your product meets the needs of your target market and provides real value. This is a positive signal for potential investors and helps build a strong foundation for scaling.

By focusing on **measures of customer retention**, businesses can build a more stable, profitable, and scalable operation.

## Key Customer Retention Metrics (KPIs) You Should Track

To get a clear picture of how well you're keeping customers, you need to monitor several key **customer retention metrics**, often called Key Performance Indicators (KPIs). These **user retention metrics** and **client retention metrics** provide different views of customer loyalty and business health.

1.  **Customer Retention Rate (CRR):** This fundamental metric shows the percentage of customers who remain with your service over a specific period. It directly measures your ability to hold onto your customer base.
2.  **Customer Churn Rate:** The opposite of CRR, this metric indicates the percentage of customers who stop using your service during a specific period. High churn can point to problems with satisfaction, product value, or competition.
3.  **Net Revenue Retention (NRR):** A powerful SaaS metric, NRR measures the percentage of recurring revenue retained from existing customers. It includes revenue changes from expansions (upsells, cross-sells) and contractions (downgrades), alongside churn. An NRR over 100% signals healthy growth from your existing customer base.
4.  **Gross Revenue Retention (GRR):** GRR focuses on the revenue retained from initial subscriptions, excluding expansion revenue. It highlights how well you prevent revenue loss from customer churn and downgrades.
5.  **Customer Lifetime Value (CLTV):** CLTV estimates the total revenue a business can expect from a single customer account throughout their entire relationship. Understanding CLTV helps make decisions about spending on acquisition and retention.
6.  **Customer Acquisition Cost (CAC):** CAC is the total cost spent to acquire a new customer. While an acquisition metric, it's closely tied to retention. A sustainable business needs a healthy CLTV:CAC ratio, meaning customers generate significantly more value than the cost to acquire them.
7.  **Repeat Customer Rate:** This measures the percentage of customers who make more than one purchase or continue using the service after their initial engagement. It indicates loyalty and ongoing value perception.
8.  **Purchase Frequency Rate:** This shows how often customers make purchases or interact significantly with your service within a set time. Higher frequency suggests strong engagement.
9.  **Net Promoter Score (NPS):** NPS measures customer loyalty by asking how likely users are to recommend your product to others. It segments customers into Promoters, Passives, and Detractors, offering insights into advocacy and churn risk.
10. **Customer Satisfaction Score (CSAT):** CSAT measures customer satisfaction with specific interactions or the overall product/service, usually through direct feedback questions.
11. **Customer Effort Score (CES):** CES measures how much effort a customer had to exert to interact with your company (e.g., get support, make a purchase). Lower effort often correlates with higher satisfaction.
12. **Engagement Rate:** This tracks how actively customers use your product or specific features. Metrics like Daily Active Users (DAU), Monthly Active Users (MAU), and Feature Adoption Rate fall under this category. High engagement suggests customers find value.
13. **Renewal Rate:** For subscription businesses, this tracks the percentage of customers who renew their subscriptions when their term ends. It's a direct measure of commitment.

Monitoring these diverse **customer retention KPIs** gives you a comprehensive view of performance, helping identify strengths and areas for improvement.

## How to Measure Client Retention: Key Formulas

Accurate measurement depends on using the correct formulas. Here’s **how you measure retention** using standard calculations for essential **client retention metrics**:

| Metric                              | Formula                                                                                                                                                                       |
| :---------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Customer Retention Rate (CRR)**   | `((Customers at End of Period - New Customers Acquired) / Customers at Start of Period) * 100`                                                                                |
| **Customer Churn Rate**             | `(Customers Lost During Period / Customers at Start of Period) * 100`                                                                                                         |
| **Net Revenue Retention (NRR)**     | `((Starting MRR + Expansion MRR - Churned MRR - Contraction MRR) / Starting MRR) * 100` (Note: Churned MRR includes full cancellations, Contraction MRR refers to downgrades) |
| **Gross Revenue Retention (GRR)**   | `((Starting MRR - Churned MRR - Contraction MRR) / Starting MRR) * 100` (Focuses only on retaining initial revenue value)                                                     |
| **Customer Lifetime Value (CLTV)**  | `Average Revenue Per Account (ARPA) / Customer Churn Rate` (One common method; others exist)                                                                                  |
| **Customer Acquisition Cost (CAC)** | `Total Sales and Marketing Costs / Number of New Customers Acquired`                                                                                                          |
| **Repeat Customer Rate**            | `(Customers with >1 Purchase / Total Customers) * 100`                                                                                                                        |
| **Purchase Frequency Rate**         | `Total Orders / Total Unique Customers` (Over a specific period)                                                                                                              |
| **Net Promoter Score (NPS)**        | `Percentage of Promoters - Percentage of Detractors`                                                                                                                          |
| **Customer Satisfaction (CSAT)**    | `(Number of Satisfied Responses / Total Number of Responses) * 100`                                                                                                           |
| **Customer Effort Score (CES)**     | `Sum of Effort Scores / Total Number of Responses` OR `Percentage of Positive Responses - Percentage of Negative Responses`                                                   |
| **Engagement Rate**                 | `(Number of Engaged Users / Total Number of Users) * 100` (Definition of "Engaged" varies)                                                                                    |
| **Renewal Rate**                    | `(Customers Who Renewed / Customers Up for Renewal) * 100`                                                                                                                    |

Using these formulas consistently allows you to track performance accurately over time. Remember that CLTV can be calculated in several ways; choose the method that best fits your business data and model.

## Understanding SaaS Retention Benchmarks

Industry benchmarks help you understand how your retention performance compares to others. These numbers can vary based on company size (measured by Annual Recurring Revenue - ARR), target market (SMB, Mid-Market, Enterprise), and industry vertical.

- **Customer Retention Rate (CRR):** Annual CRR goals often differ: Enterprise SaaS aims for >95%, Mid-Market around 90%, and SMB SaaS above 85%. Median CRR tends to improve as companies grow larger. Top performers often see 85-87% customer retention annually.
- **Customer Churn Rate:** Average annual churn is often cited between 5-7% for established SaaS companies, but startups might see 10-15% or higher. Monthly churn below 1% is considered good. Smaller companies (under $10M ARR) can experience much higher churn (over 20%) compared to larger ones (around 8.5%).
- **Net Revenue Retention (NRR):** Healthy NRR is typically above 100%, meaning growth from existing customers outpaces losses. The median NRR across SaaS was recently reported around 102%. Top bootstrapped companies can reach 120%+.
- **Gross Revenue Retention (GRR):** The median GRR across SaaS was recently reported at 91%. Good GRR is often considered 80%+ for SMB-focused SaaS and 90%+ for Enterprise. A healthy range is generally 85-95%.
- **CLTV to CAC Ratio:** An ideal ratio is often 3:1 or 4:1, meaning customer lifetime value is three to four times the cost of acquisition. B2B SaaS might aim even higher.
- **Net Promoter Score (NPS):** Scores above 0 are good, above 20 favorable, above 50 excellent, and above 80 world-class. The SaaS industry average is around +28.
- **Repeat Customer Rate:** For e-commerce, 25-30% is a good benchmark. This offers context for SaaS businesses with transactional components.

Use these benchmarks as reference points, but always consider your specific business context when evaluating your own **retention metrics**.

## Strategies to Improve Customer Retention

Improving **user retention metrics** requires a deliberate approach focused on the customer experience. Here are effective strategies:

- **Optimize Onboarding:** Ensure new users quickly understand your product's value and achieve early success. Use clear guidance, tutorials, and personalized setup help.
- **Engage Proactively:** Communicate regularly beyond basic transactions. Offer support before problems arise, share useful content, and ask for feedback. Show you care about their success.
- **Personalize the Experience:** Use customer data to tailor communications, recommendations, and support. Make customers feel understood and valued.
- **Build Product Stickiness:** Design your product to become essential to the customer's workflow. Focus on usability, valuable features, and creating usage habits.
- **Provide Excellent Support:** Offer timely, helpful, and empathetic support through the channels your customers prefer. Resolve issues effectively and efficiently.
- **Collect and Act on Feedback:** Regularly ask customers for their opinions through surveys (NPS, CSAT, CES) and feedback forms. Show them you listen by making improvements based on their input.
- **Implement Loyalty Programs:** Reward long-term customers with points, discounts, or exclusive benefits to encourage continued business.
- **Continuously Improve Your Product:** Regularly update your software with enhancements, new features, and bug fixes based on feedback and market needs. Keep customers informed about improvements.
- **Offer Referral Programs:** Encourage satisfied customers to refer others by offering incentives for successful referrals.
- **Build a Community:** Create a space (like a forum or user group) where customers can connect, share best practices, and learn from each other.
- **Address Churn Proactively:** Monitor user engagement and identify customers at risk of leaving. Reach out to understand their issues and offer solutions before they decide to cancel.

A combination of these strategies, adapted to your specific customers and product, can significantly improve your **customer retention metrics**.

## Retention Metrics and Overall Business Health

**Customer retention metrics** don't exist in isolation. They directly influence other critical business indicators:

- **CLTV:** Higher retention directly leads to higher Customer Lifetime Value. Customers who stay longer simply generate more revenue.
- **CAC:** Good retention reduces the pressure and cost associated with acquiring new customers constantly. A healthy CLTV:CAC ratio (e.g., 3:1+) indicates a sustainable model driven by retained customer value.
- **MRR/ARR:** High retention creates stable and predictable Monthly Recurring Revenue (MRR) and Annual Recurring Revenue (ARR), the foundation of SaaS growth. High churn erodes these figures.
- **Profitability:** Retained customers often cost less to serve, are more likely to upgrade, and provide valuable referrals, all contributing positively to your bottom line.

Improving retention creates a positive ripple effect across your business, leading to more sustainable and profitable growth.

## Tools for Tracking Customer Retention Metrics

Several types of tools can help you track, analyze, and report on **retention metrics**:

- **SaaS Analytics Platforms:** (e.g., [LogSnag](https://logsnag.com), Baremetrics, ProfitWell, ChartMogul, Mixpanel, Amplitude) These tools specialize in tracking metrics like MRR, churn, CLTV, NRR, and GRR, often providing detailed dashboards and cohort analysis.
- **Customer Relationship Management (CRM) Systems:** (e.g., HubSpot, Salesforce, Zoho CRM) CRMs centralize customer data and interaction history, providing context for retention efforts and tracking related activities.
- **Customer Success Platforms:** (e.g., Userpilot, Custify, Gainsight, ChurnZero) These platforms are built specifically for retention, offering features like health scoring, automated engagement workflows, onboarding tools, and churn prediction.
- **Customer Feedback Tools:** (e.g., [UserJot](https://userjot.com/), Canny, UserVoice, Nolt) These help you collect NPS, CSAT, CES, and other qualitative feedback to understand customer sentiment and identify areas for improvement.

Choosing the right tools, and often integrating them, provides a clearer picture of customer behavior and helps make your retention strategies more effective.

## Common Challenges in Measuring Retention

While tracking **customer retention metrics** is important, businesses often face challenges:

- **Choosing the Right Metrics:** Identifying the most relevant metrics for your specific business model can be difficult. Focusing on vanity metrics over actionable ones is a common mistake.
- **Data Accuracy and Integration:** Customer data often lives in different systems. Ensuring data is accurate and flows correctly between tools is crucial for reliable measurement.
- **Understanding the "Why":** Quantitative metrics show _what_ is happening (e.g., churn rate), but qualitative feedback is needed to understand _why_ customers leave. Gathering this feedback effectively takes effort.
- **Attribution:** It can be hard to determine which specific actions directly led to retention improvements, making it difficult to know which strategies are most effective.
- **Balancing Short-Term vs. Long-Term:** Focusing too much on immediate revenue might lead to actions that harm long-term customer loyalty and retention.
- **One-Size-Fits-All Approach:** Different customer segments have different needs. Applying the same retention strategy to everyone is often ineffective. Segmentation is key.
- **Identifying Early Warning Signs:** Waiting until a customer is already canceling is often too late. Recognizing early indicators of churn risk requires proactive monitoring.
- **Cost vs. Benefit:** Investing in retention is necessary, but spending must be strategic and aligned with the potential lifetime value of the customers you are trying to keep.

Being aware of these challenges helps you develop a more robust and effective approach to measuring and improving customer retention.

## Final Thoughts

Understanding and improving **customer retention metrics** is not just a task for the customer success team; it's a strategic necessity for any SaaS business aiming for long-term, sustainable growth. By focusing on delivering ongoing value, listening to customers, and actively working to keep them engaged, you build a loyal customer base. This loyalty translates directly into predictable revenue, lower costs, higher lifetime value, and ultimately, a healthier, more profitable business. Use the **measures of customer retention** discussed here as your guideposts on the path to building lasting customer relationships.

# Design Mockup

Source: https://userjot.com/definitions/design-mockup
Updated: 2025-01-28

> A design mockup is a static, high-fidelity picture of a screen that shows layout, color, and type so stakeholders can review it before any code is written.

Design Mockups are essential tools in the design process. They allow designers to explore different layouts, color schemes, and user interfaces without the need for coding. By creating a mockup, designers can test various design elements and get feedback from team members or clients before moving forward with development.

To create a Design Mockup, designers typically use specialized software like Adobe XD, Sketch, or Figma. These tools provide a range of features that make it easy to design and iterate on mockups. The process starts with sketching out rough ideas on paper or digitally, then refining these ideas into a more detailed mockup.

Once a mockup is created, it's important to share it with stakeholders for feedback. This can include other designers, product managers, or potential users. Feedback helps to identify any issues or areas for improvement, allowing the design to be refined before development begins. This iterative process ensures that the final product meets the needs and expectations of users.

Design Mockups can vary in fidelity, from low-fidelity sketches to high-fidelity, interactive prototypes. Low-fidelity mockups are quick to create and useful for exploring early ideas, while high-fidelity mockups provide a more accurate representation of the final product. The level of detail depends on the stage of the design process and the specific goals of the mockup.

In addition to helping with design decisions, Design Mockups also serve as a communication tool. They provide a clear visual reference that can be used to explain the design to developers, ensuring that everyone is on the same page. This can help to prevent misunderstandings and reduce the need for costly changes during development.

Overall, Design Mockups are a crucial part of the design process. They help to plan, communicate, and refine design ideas, ensuring that the final product is well-designed and meets the needs of users. By using mockups effectively, designers can create better products and improve the overall design process.

# Empathy Map

Source: https://userjot.com/definitions/empathy-map
Updated: 2025-01-25

> An empathy map is a one-page canvas capturing what a user says, thinks, does, and feels, so a team designs for the real person rather than an assumption.

An Empathy Map is a visual representation that captures key aspects of a user's experience. It is typically divided into four quadrants: Says, Thinks, Does, and Feels. Each quadrant focuses on a different dimension of the user's experience, providing a comprehensive view of their perspective.

The "Says" quadrant captures what the user says out loud in interviews or conversations. This can include direct quotes or paraphrased statements that reflect their opinions and experiences. By documenting what users say, teams can identify common themes and pain points.

The "Thinks" quadrant focuses on what the user is thinking, which may not always be expressed verbally. This includes their beliefs, assumptions, and internal thoughts about the product or service. Understanding what users think helps teams to uncover hidden motivations and concerns.

The "Does" quadrant documents the user's actions and behaviors. This includes what they do in relation to the product or service, such as how they use it, how often they use it, and any workarounds they employ. Observing what users do provides valuable insights into their actual behavior and usage patterns.

The "Feels" quadrant captures the user's emotions and feelings. This includes their emotional responses to the product or service, such as frustration, satisfaction, or excitement. Understanding how users feel helps teams to design experiences that evoke positive emotions and address negative ones.

To create an Empathy Map, teams typically gather data from user interviews, observations, and other research methods. This data is then synthesized and organized into the four quadrants. The resulting map provides a holistic view of the user's experience, helping teams to identify opportunities for improvement and innovation.

Empathy Maps are particularly useful in the early stages of product development, as they help teams to align on the user's perspective and prioritize features that address their needs. They can also be used throughout the development process to validate assumptions and ensure that the product remains user-centered.

In summary, an Empathy Map is a powerful tool for understanding users. By capturing what users say, think, do, and feel, teams can gain deeper insights into their needs and design products that deliver value. Empathy Maps help to foster a user-centered approach to product development, leading to better outcomes for both users and the business.

# Feature Creep

Source: https://userjot.com/definitions/feature-creep
Updated: 2025-01-21

> Feature creep is the gradual addition of features beyond a product's original scope during development, which stretches timelines and adds complexity.

Feature creep often starts with small additions that seem harmless but can accumulate over time. These additions might come from stakeholders, customers, or the development team itself. Without careful management, these extra features can shift focus away from the product's core objectives. For instance, a simple request to add a new button might seem minor, but if it leads to further requests for additional functionalities, the project can quickly become unmanageable.

To control feature creep, product managers should set clear project goals and priorities from the start. Establishing a well-defined product roadmap is essential. This roadmap should outline the key features and milestones that are critical to the product's success. Regularly reviewing the product roadmap helps ensure that any new features align with these goals. It's also important to assess the impact of new features on the project timeline and resources before adding them. This assessment should consider not only the immediate effects but also the long-term implications on the product's maintainability and user experience.

Effective communication with stakeholders is key to managing feature creep. Product managers should explain the reasons for rejecting certain feature requests and focus on the benefits of maintaining a clear and focused product vision. By keeping everyone aligned on the project's objectives, product managers can reduce the risk of feature creep. Regular meetings and updates can help keep stakeholders informed about the project's progress and any changes to the scope.

Another strategy to manage feature creep is to implement a change management process. This process should require any new feature requests to go through a formal review and approval process. By doing so, product managers can evaluate the necessity and impact of each request before deciding whether to incorporate it into the project. This helps prevent unnecessary features from being added without proper consideration.

Additionally, product managers can use prioritization techniques like the MoSCoW method (Must have, Should have, Could have, Won't have) to categorize feature requests. This method helps in deciding which features are essential for the product's success and which ones can be deferred or dropped altogether. By focusing on the 'Must have' features, product managers can ensure that the core value of the product is delivered without getting sidetracked by less important additions.

In some cases, feature creep can be mitigated by releasing the product in phases. This approach allows product managers to deliver a minimum viable product (MVP) first, gather feedback, and then add new features in subsequent releases. This iterative process helps in managing the scope of the project and ensures that new features are added only after validating their need and impact.

Overall, managing feature creep requires a combination of clear goal-setting, effective communication, rigorous change management, and strategic prioritization. By employing these techniques, product managers can keep their projects focused, deliver products on time and within budget, and ultimately achieve greater success in meeting customer needs and expectations.

# Feature Flag

Source: https://userjot.com/definitions/feature-flag
Updated: 2025-01-28

> A feature flag is a switch in code that turns a feature on or off at runtime without a new deploy, so teams can test in production and roll back instantly.

Feature Flags are useful for managing the rollout of new features. Developers can turn a feature on for a small group of users to test its performance and gather feedback. If the feature works well, they can gradually increase the number of users who have access to it. This approach helps in reducing the risk associated with new releases.

To implement Feature Flags, developers add conditional statements in the code that check the status of a flag. If the flag is enabled, the feature is active; if it's disabled, the feature remains hidden. This method allows for quick changes without the need for a full code deployment.

Feature Flags also support A/B testing, where different versions of a feature can be shown to different user groups. This helps in comparing the effectiveness of different features and making data-driven decisions about which version to keep.

Another benefit of Feature Flags is the ability to roll back features easily. If a new feature causes issues, developers can simply disable the flag to revert to the previous version of the software. This quick rollback capability is crucial for maintaining system stability and user satisfaction.

In addition, Feature Flags can be used for managing different environments. For example, a feature might be enabled in a development environment but disabled in production until it's fully tested. This separation helps in keeping the production environment stable while allowing for experimentation in other environments.

Overall, Feature Flags provide a flexible way to manage software features. They enable developers to control the release process, test new features safely, and respond quickly to any issues that arise. By using Feature Flags, businesses can improve their software development process and deliver better products to their users.

# Feature Release

Source: https://userjot.com/definitions/feature-release
Updated: 2025-01-20

> A feature release is the planned delivery of new functionality to users: build, testing, deployment, and the announcement that tells them it shipped.

A feature release typically starts with identifying the need for new functionalities or improvements. This can come from customer feedback, market research, or internal product strategy. Once the need is identified, product managers work with stakeholders to prioritize the features based on their potential impact and the resources available.

The next step in a feature release is the development phase. Developers work on implementing the new features, following the product specifications and design guidelines. This phase often involves collaboration between developers, designers, and product managers to ensure that the features are built correctly and meet the intended goals.

Testing is a critical part of the feature release process. Quality assurance teams conduct various tests to ensure that the new features work as expected and do not introduce any bugs or issues. This includes unit testing, integration testing, and user acceptance testing. Any issues identified during testing are addressed and fixed before moving forward with the release.

Once the features are developed and tested, the deployment phase begins. This involves rolling out the new features to the users. Depending on the product and the organization's practices, this can be done through a full release, a phased rollout, or using feature flags to control the activation of the new functionalities. The deployment process should be planned carefully to minimize disruptions and ensure a smooth transition for users.

After the feature release, it's important to gather feedback from users. This feedback helps to assess the impact of the new features and identify any areas for improvement. Product managers should monitor the performance of the new features and make adjustments as needed to ensure that they continue to meet the needs of the users.

In summary, a feature release is a structured process that involves planning, development, testing, deployment, and feedback. By following these steps, product managers can successfully introduce new functionalities or improvements to a product, enhancing its value and meeting the needs of users.

# Freemium Business Model

Source: https://userjot.com/definitions/freemium-business-model
Updated: 2025-01-21

> Freemium is a pricing model where the basic product is free forever and advanced features cost money, built to attract a large base and convert a share.

The free version of a freemium product often has limitations, such as fewer features, usage restrictions, or advertisements. These limitations are designed to encourage users to upgrade to the paid version, which provides a more complete and enhanced experience. The goal is to provide enough value in the free version to attract users, while also creating a compelling reason to pay for the premium features.

One key advantage of the freemium model is its ability to quickly build a large user base. The free offering reduces barriers to entry, allowing many users to try the product or service without any upfront cost. This can lead to increased brand awareness and a larger pool of potential customers. However, it's crucial to ensure that the free version is valuable enough to keep users engaged.

For a freemium model to be successful, the conversion rate from free to paid users needs to be high enough to sustain the business. This requires careful planning of the free and paid offerings. The free version should provide a taste of the product's value, while the paid version should offer significant advantages that justify the cost. It's also important to continuously monitor user behavior and feedback to optimize the conversion funnel.

The freemium model also requires a clear understanding of the target audience and their needs. The free version should appeal to a broad audience, while the paid version should cater to users who need more advanced features or capabilities. It's also important to consider the pricing of the paid version and ensure that it's competitive and aligned with the value it provides.

In addition, the freemium model can be challenging to manage. It requires a balance between providing enough value in the free version to attract users and creating a compelling reason to upgrade to the paid version. It also requires ongoing monitoring and optimization to ensure that the business is sustainable. However, when implemented effectively, the freemium model can be a powerful way to acquire users and build a successful business.

# Go-to-Market Strategy

Source: https://userjot.com/definitions/go-to-market-strategy
Updated: 2025-01-25

> A go-to-market (GTM) strategy is the plan for reaching target customers with a new product: positioning, pricing, channels, and launch tactics.

A Go-to-Market strategy is essential for any business looking to introduce a new product or service to the market. It helps to ensure that the launch is well-planned and executed, maximizing the chances of success. The strategy covers various aspects, including market segmentation, product positioning, sales and distribution channels, pricing, and marketing and promotional activities.

The first step in developing a GTM strategy is to identify and understand the target market. This involves segmenting the market based on factors such as demographics, needs, and behaviors. By understanding the target audience, a company can tailor its messaging and offerings to meet their specific needs and preferences.

Product positioning is another critical element of a GTM strategy. It involves defining how the product or service will be perceived in the market relative to competitors. Effective positioning highlights the unique value proposition of the product and differentiates it from other offerings. This can be achieved through clear and compelling messaging that resonates with the target audience.

Choosing the right sales and distribution channels is also crucial for a successful GTM strategy. The channels should be selected based on the target market and the nature of the product. Options include direct sales, online platforms, retail stores, or partnerships with distributors. The goal is to ensure that the product is accessible to the target customers through their preferred channels.

Pricing is another key component of a GTM strategy. It involves setting a price that reflects the value of the product and is competitive within the market. The pricing strategy should consider factors such as production costs, target market willingness to pay, and competitor pricing. The aim is to maximize profitability while remaining attractive to customers.

Marketing and promotional activities are essential for raising awareness and generating demand for the product. A GTM strategy should outline the marketing channels and tactics to be used, such as social media, content marketing, advertising, and public relations. The strategy should also include a plan for measuring the effectiveness of these activities and adjusting them as needed.

In addition to these elements, a GTM strategy should also consider the resources and capabilities required for execution. This includes the team responsible for implementing the strategy, the budget allocated to different activities, and any external partners or vendors needed. Ensuring that the necessary resources are in place is crucial for the successful implementation of the GTM strategy.

In summary, a Go-to-Market strategy is a comprehensive plan that guides a company in launching and selling a new product or service. By addressing key aspects such as market segmentation, product positioning, sales and distribution channels, pricing, and marketing activities, a well-crafted GTM strategy can help a company achieve competitive advantage and reach its target customers effectively.

# Market Segmentation

Source: https://userjot.com/definitions/market-segmentation
Updated: 2025-01-28

> Market segmentation divides a market into groups of customers with similar needs or traits so a business can tailor its product and messaging to each.

Market segmentation involves identifying and analyzing different groups within a broader market. These groups, or segments, are defined based on various criteria such as demographics, geographic location, psychographics, and behavior. By understanding the unique needs and preferences of each segment, companies can develop targeted marketing strategies that resonate more effectively with their audience.

Demographic segmentation is one of the most common methods, where the market is divided based on factors like age, gender, income, education, and family status. For example, a company might target young adults with a new line of trendy clothing, while offering luxury products to high-income consumers.

Geographic segmentation divides the market based on location, such as country, region, city, or neighborhood. This approach can be useful for businesses that need to account for regional differences in consumer behavior, climate, or cultural preferences. A restaurant chain, for instance, might adapt its menu to suit local tastes in different cities.

Psychographic segmentation focuses on the psychological aspects of consumer behavior, including lifestyle, values, attitudes, and interests. This method helps companies connect with consumers on a deeper level by aligning their products or services with the consumers' values and aspirations. A fitness brand might target health-conscious individuals who value an active lifestyle.

Behavioral segmentation categorizes consumers based on their behavior towards products or services, such as usage rate, brand loyalty, and purchase occasions. This approach can help businesses identify their most valuable customers and develop strategies to increase customer retention and loyalty. For example, a software company might offer premium features to frequent users while providing basic services to occasional users.

Effective market segmentation requires thorough research and analysis. Companies must gather and analyze data to understand the needs, preferences, and behaviors of different segments. This information can then be used to develop targeted marketing campaigns, product features, and pricing strategies that appeal to each segment.

By implementing market segmentation, businesses can improve their marketing efficiency, increase customer satisfaction, and ultimately drive higher sales and profits. Tailoring products and marketing messages to specific segments helps companies stand out in a competitive market and build stronger relationships with their customers.

# Merchant of Record (MOR)

Source: https://userjot.com/definitions/merchant-of-record-mor
Updated: 2025-01-28

> A Merchant of Record (MOR) is the legal seller in a transaction, handling payment processing, sales tax, and compliance for the business it sells for.

The role of a Merchant of Record is crucial for businesses, especially those operating online or in multiple regions. The MOR handles the complexities of payment processing, ensuring that transactions are secure and compliant with various laws and regulations. This includes managing credit card processing, handling chargebacks, and ensuring that taxes are correctly calculated and remitted.

For businesses, using a Merchant of Record can simplify operations. Instead of managing these aspects themselves, businesses can focus on their core activities while the MOR takes care of the financial and legal details. This is particularly beneficial for companies expanding into new markets, as the MOR can navigate the local regulations and payment systems.

The process of working with a Merchant of Record involves several steps. First, a business must select a suitable MOR that aligns with their needs and operates in the regions where they do business. Once selected, the business and the MOR establish a contract that outlines the terms of their partnership, including fees, responsibilities, and the scope of services.

After the contract is in place, the MOR integrates with the business's sales platform. This integration allows the MOR to process payments seamlessly when customers make purchases. The MOR collects payment information, processes the transaction, and ensures that funds are transferred to the business's account.

Throughout the transaction process, the MOR also handles customer service related to payments. This includes addressing any issues with transactions, managing refunds, and dealing with chargebacks. By taking on these responsibilities, the MOR helps to maintain a positive customer experience and reduces the burden on the business.

In addition to payment processing, the MOR is responsible for ensuring compliance with local and international regulations. This includes adhering to data protection laws, managing tax obligations, and following industry standards for payment security. The MOR's expertise in these areas helps businesses avoid legal issues and maintain trust with their customers.

In summary, a Merchant of Record (MOR) plays a vital role in managing the financial and legal aspects of transactions for businesses. By handling payment processing, tax compliance, and customer service, the MOR allows businesses to focus on their core operations while ensuring that transactions are secure and compliant with regulations.

# Minimum Viable Product

Source: https://userjot.com/definitions/minimum-viable-product
Updated: 2025-01-28

> A Minimum Viable Product (MVP) is the smallest version of a product early customers can use and react to, built to test an idea with the least effort.

A Minimum Viable Product focuses on the core functionality that solves a specific problem for users. By launching an MVP, businesses can gather valuable insights from real users without fully developing the product. This approach reduces the risk of investing in features that users might not need or want.

Creating an MVP involves identifying the essential features that address the primary needs of the target audience. These features should be enough to make the product usable and valuable to early adopters. Once the MVP is launched, businesses can collect feedback from users to understand what works well and what needs improvement.

The feedback gathered from the MVP helps businesses to iterate and refine the product. By making incremental improvements based on user input, businesses can develop a product that better meets the needs of their customers. This iterative process also allows businesses to validate their product ideas and business model before committing to a full-scale launch.

Using an MVP can save time and resources. Instead of spending months or years developing a complete product, businesses can launch a simpler version and start learning from real users. This approach enables faster market entry and reduces the risk of building a product that fails to gain traction.

In summary, a Minimum Viable Product is a strategic tool for testing and refining product ideas. By focusing on core features and gathering user feedback, businesses can develop products that meet customer needs more effectively and efficiently.

# Net Promoter Score (NPS)

Source: https://userjot.com/definitions/net-promoter-score-nps
Updated: 2025-01-28

> Net Promoter Score (NPS) measures loyalty from one question: how likely are you to recommend us, 0 to 10. Score = % promoters (9–10) − % detractors (0–6).

NPS categorizes respondents into three groups based on their scores. Those who give a score of 9 or 10 are considered Promoters. These customers are highly satisfied and likely to recommend the company. Respondents who give a score of 7 or 8 are considered Passives. They are satisfied but not enthusiastic enough to actively promote the company. Lastly, those who give a score of 0 to 6 are considered Detractors. These customers are unhappy and may even discourage others from using the company's products or services.

To calculate the NPS, subtract the percentage of Detractors from the percentage of Promoters. The result is a score that can range from -100 to 100. A positive score indicates that a company has more Promoters than Detractors, which is generally seen as a sign of good customer satisfaction and loyalty. A score above 0 is considered acceptable, while a score above 50 is considered excellent.

NPS is valuable because it provides a simple yet powerful way to measure customer sentiment. It helps companies identify areas for improvement and track changes in customer satisfaction over time. By regularly surveying customers and calculating their NPS, companies can gain insights into their performance and make data-driven decisions to enhance their products and services.

In addition to the numerical score, many companies follow up the NPS question with an open-ended question asking respondents to explain their score. This qualitative feedback can provide deeper insights into what customers appreciate or dislike about the company. It can also help identify specific issues that need to be addressed to improve customer satisfaction.

NPS is widely used across various industries, from technology and retail to healthcare and finance. It serves as a benchmark for comparing customer loyalty and satisfaction among competitors. Companies often share their NPS publicly as a way to demonstrate their commitment to customer satisfaction and to attract new customers.

In summary, Net Promoter Score (NPS) is an effective tool for measuring customer loyalty and satisfaction. By categorizing customers into Promoters, Passives, and Detractors, and calculating a score based on their responses, companies can gain valuable insights into their performance. Regularly tracking NPS and analyzing the feedback can help companies improve their products and services, ultimately leading to higher customer satisfaction and loyalty.

# North Star Metric

Source: https://userjot.com/definitions/north-star-metric
Updated: 2025-01-28

> A North Star Metric is the single number that best captures the value a product delivers to customers, used to align every team's work toward one goal.

The North Star Metric serves as a focal point for all activities within an organization. By identifying and focusing on this metric, companies can align their teams and strategies around a common goal. This alignment helps to ensure that everyone is working toward the same objective, increasing the likelihood of achieving sustainable growth.

To determine the North Star Metric, companies need to understand what drives value for their customers. This involves analyzing customer behavior and identifying the key actions that lead to engagement, retention, and ultimately, revenue. For example, a social media platform might choose "daily active users" as its North Star Metric, as this reflects the level of engagement and value the platform provides to its users.

Once identified, the North Star Metric should be used to guide decision-making across the organization. Product development, marketing, and customer support teams should all consider how their efforts contribute to improving this metric. By focusing on initiatives that directly impact the North Star Metric, companies can prioritize their resources effectively and drive meaningful progress toward their core objective.

It's important for companies to regularly monitor and analyze their North Star Metric. This involves tracking the metric over time and understanding the factors that influence its performance. By doing so, companies can identify trends, spot opportunities for improvement, and make data-driven decisions to optimize their strategies.

While the North Star Metric is a powerful tool for guiding a company's growth, it should not be used in isolation. Companies should also consider other key performance indicators that provide a more comprehensive view of their performance. These supporting metrics can help to provide context and insights into the factors that drive the North Star Metric.

In summary, the North Star Metric is a crucial indicator that helps companies focus on their core objective and drive long-term growth. By identifying the key metric that reflects customer value, aligning teams around this goal, and regularly monitoring its performance, companies can make informed decisions and prioritize their efforts effectively.

# Objectives and Key Results (OKRs)

Source: https://userjot.com/definitions/objectives-and-key-results-okrs
Updated: 2025-01-21

> OKRs are a goal-setting framework pairing an Objective, a qualitative statement of what to achieve, with Key Results, the measurable outcomes proving it.

The Objective component of an OKR should be ambitious and inspiring, setting a clear direction for the team or individual. It should be qualitative, describing the desired outcome rather than specific tasks. For example, an Objective might be "Improve User Engagement" or "Become the Leading Platform in the Market." The Objective serves as a guiding star, motivating the team to strive for a significant achievement.

Key Results, on the other hand, are quantitative and measurable metrics that demonstrate progress towards the Objective. They should be specific, achievable, and time-bound, allowing for easy tracking and assessment of performance. For example, Key Results for the Objective "Improve User Engagement" might include "Increase daily active users by 15%" or "Reduce bounce rate by 10%." Key Results provide concrete evidence of whether the Objective is being met.

Effective OKRs are typically set on a quarterly basis, with regular check-ins to monitor progress and make adjustments as needed. They promote a culture of transparency and accountability, as everyone is aware of the goals and how they are being measured. OKRs also encourage teams to think strategically about their work and prioritize activities that will have the greatest impact on achieving the desired outcomes.

By using the OKR framework, product managers can effectively define and communicate their product vision, align their teams around shared goals, and track progress towards success. OKRs help to ensure that product development efforts are focused on delivering value to users and achieving the organization's broader objectives. They provide a clear and measurable way to assess performance and make data-driven decisions, ultimately contributing to the success of the product and the organization as a whole.

# Open Rate

Source: https://userjot.com/definitions/open-rate
Updated: 2025-01-28

> Open rate is the percentage of delivered emails that recipients opened: opens ÷ delivered × 100. It reflects subject lines and sender trust, not body copy.

The open rate is calculated by dividing the number of emails opened by the total number of emails sent, then multiplying the result by 100 to get a percentage. This metric is crucial for businesses to assess the success of their email marketing efforts. A high open rate indicates that the subject line and sender's name are compelling enough to encourage recipients to open the email.

To improve the open rate, businesses need to focus on crafting engaging subject lines that grab the recipient's attention. The subject line should be clear, concise, and relevant to the content of the email. It's also important to consider the timing of the email, as sending it at the right time can increase the likelihood of it being opened.

Another factor that can influence the open rate is the sender's name. Using a recognizable and trusted sender name can increase the chances of the email being opened. Personalizing the sender's name or using the company's name can also make the email feel more relevant to the recipient.

Tracking the open rate over time allows businesses to identify trends and make data-driven decisions about their email marketing strategy. By analyzing which types of emails have higher open rates, businesses can refine their approach and focus on creating content that resonates with their audience.

In addition to improving engagement, a high open rate can also lead to better click-through rates and conversions. When more people open the email, there's a greater opportunity for them to engage with the content and take the desired action, such as making a purchase or signing up for a service.

Overall, the open rate is a valuable metric for businesses to monitor and optimize. By understanding what drives recipients to open their emails, businesses can create more effective email marketing campaigns and build stronger relationships with their audience.

# Product Manager

Source: https://userjot.com/definitions/product-manager
Updated: 2025-01-21

> A product manager owns a product's strategy, roadmap, and delivery, acting as the voice of the customer between business, engineering, and design.

Product managers work closely with various teams, including engineering, design, and marketing. They define the product vision, set priorities, and make decisions about what to build and when. They gather and analyze user feedback, market trends, and competitive landscapes to inform product decisions. This data-driven approach helps in creating a product that is both valuable and viable.

A key part of a product manager's role is creating and maintaining a product roadmap. This roadmap outlines the planned features and enhancements for the product over time. The product manager is responsible for communicating this roadmap to stakeholders and ensuring that everyone is aligned on the product's direction. They also prioritize features based on their impact and feasibility, making sure that the development team focuses on the most important tasks.

Product managers also play a crucial role in defining user stories and requirements. They work with designers and engineers to translate user needs into actionable tasks. They ensure that the product meets the required functionality and quality standards. They also participate in the testing and validation process, making sure that the product works as intended and provides a seamless user experience.

Furthermore, product managers are responsible for monitoring the performance of the product after its launch. They track key metrics, analyze user behavior, and identify areas for improvement. They use this data to make informed decisions about future enhancements and iterations. They also work with marketing and sales teams to promote the product and ensure its success in the market.

Product managers also need strong communication and leadership skills. They act as a central point of contact for the product, facilitating collaboration and resolving conflicts. They need to be able to articulate the product vision clearly and persuasively to different audiences. They also need to be adaptable and able to respond to changing market conditions and user feedback.

In summary, a product manager is a multifaceted role that requires a blend of strategic thinking, technical understanding, and strong interpersonal skills. They are the driving force behind a product's success, ensuring that it meets both user needs and business objectives. They are responsible for the entire product lifecycle, from ideation to launch and beyond, and play a vital role in shaping the future of the product.

# Product Market Fit

Source: https://userjot.com/definitions/product-market-fit
Updated: 2025-01-28

> Product-market fit is the point where a product satisfies strong demand in its market: customers keep using it, recommend it, and growth comes from pull.

Product Market Fit is crucial for startups and businesses because it indicates that the product is on the right track. When a product achieves Product Market Fit, it often results in increased sales, positive customer feedback, and organic growth through word-of-mouth. This fit shows that the product solves a real problem or fulfills a need in the market.

To determine if a product has reached Product Market Fit, businesses often look at several key indicators. These include customer retention rates, repeat purchases, and the level of customer engagement. If customers are coming back to use the product and recommending it to others, it's a strong sign that the product fits well in the market.

Achieving Product Market Fit usually involves a process of iteration and feedback. Businesses start by developing a product based on their understanding of the market. They then release it to a small group of users to gather feedback. Based on this feedback, they make changes to the product, improving its features and usability. This cycle continues until the product meets the market's needs effectively.

One common method to measure Product Market Fit is the Net Promoter Score (NPS). This score asks customers how likely they are to recommend the product to others. A high NPS indicates that customers are satisfied and see value in the product, suggesting a good fit with the market.

Another approach is to conduct surveys and interviews with customers to understand their experiences and satisfaction levels. This direct feedback can provide valuable insights into what aspects of the product are working well and what areas need improvement.

In summary, Product Market Fit is essential for the success of any product. It signifies that a product not only meets but exceeds customer expectations, leading to sustainable business growth. By continuously iterating and refining the product based on market feedback, businesses can increase their chances of achieving this important milestone.

# Product Roadmap

Source: https://userjot.com/definitions/product-roadmap
Updated: 2025-01-21

> A product roadmap is the plan showing where a product is going and in what order, used to align stakeholders on priorities and set expectations on timing.

The product roadmap should clearly articulate the product’s long-term vision. This vision acts as a guide, ensuring that all development efforts contribute to a cohesive and meaningful product. The roadmap should also detail specific goals, such as increasing user engagement or expanding into new markets. These goals should be measurable and tied to the overall product strategy.

A key element of a product roadmap is the timeline. This timeline should include major milestones and release dates, providing a clear sense of progress and deadlines. However, it's important to keep the timeline flexible, allowing for adjustments based on new information or changing market conditions. The roadmap should also identify the key features and functionalities that will be developed at each stage. This helps teams understand what to prioritize and focus on.

Prioritization is a crucial aspect of roadmap planning. Product managers need to decide which features to develop first, considering factors like user needs, market opportunities, and technical feasibility. Techniques like the MoSCoW method or value vs. effort analysis can help in this process. The roadmap should reflect these priorities, ensuring that the most important features are addressed first.

The roadmap is not a static document; it should be regularly reviewed and updated. As the product evolves and new information becomes available, the roadmap may need to change. Regular reviews help ensure that the roadmap remains relevant and aligned with the product's overall goals. These reviews also provide an opportunity to gather feedback from stakeholders and make necessary adjustments.

Effective communication is essential when using a product roadmap. The roadmap should be shared with all stakeholders, including the development team, marketing, sales, and executive leadership. This ensures that everyone is aware of the product's direction and their role in achieving its goals. Regular updates and discussions about the roadmap can help keep everyone aligned and informed.

A good product roadmap should also be adaptable. It should allow for flexibility in responding to changes in the market or customer feedback. This adaptability is crucial for ensuring that the product remains competitive and relevant. By embracing a flexible approach, product teams can better navigate uncertainties and deliver a successful product.

In summary, a product roadmap is a strategic tool that guides product development and aligns stakeholders on the product's vision and goals. It should include a clear vision, measurable goals, a flexible timeline, prioritized features, and a process for regular review and updates. By effectively using a product roadmap, teams can deliver successful products that meet customer needs and achieve business objectives.

# Product-Led Sales

Source: https://userjot.com/definitions/product-led-sales
Updated: 2025-01-29

> Product-led sales lets prospects experience the product first, through a free trial or free plan, and brings in sales only once usage shows real intent.

Product-Led Sales is based on the idea that a great product can sell itself. By providing users with a hands-on experience, businesses can demonstrate the product's value and benefits, making it easier to convert users into paying customers. This approach shifts the traditional sales process, where sales teams lead the conversation, to one where the product takes center stage.

Implementing Product-Led Sales involves several key steps. First, businesses need to ensure that their product is easy to use and provides immediate value to users. This can be achieved by designing a user-friendly interface and offering features that address the users' most pressing needs. A well-designed onboarding process can also help users quickly understand and appreciate the product's capabilities.

Next, businesses should offer a way for users to try the product without a significant upfront commitment. This could be through a free trial period or a freemium model, where basic features are available for free, and advanced features require a paid subscription. By removing barriers to entry, businesses can attract more users and increase the chances of converting them into customers.

Once users are engaged with the product, businesses can use in-app messaging and notifications to guide them towards premium features and encourage upgrades. These prompts should be subtle and value-driven, highlighting how the premium features can solve specific problems or enhance the user's experience.

Product-Led Sales also involves collecting and analyzing user data to understand their behavior and preferences. This data can help businesses identify which features are most valuable to users and where they might need additional support or encouragement to upgrade. By tailoring the sales approach based on user data, businesses can increase their conversion rates and improve customer satisfaction.

Another important aspect of Product-Led Sales is the role of the sales team. While the product drives the initial engagement, sales teams play a crucial role in closing deals and nurturing long-term relationships with customers. Sales teams should be equipped with insights from user data and trained to engage with users at the right time, offering personalized solutions and addressing any concerns or questions.

Monitoring and optimizing the Product-Led Sales process is essential for success. Businesses should track key metrics such as trial-to-paid conversion rates, user engagement levels, and customer feedback. By analyzing these metrics, businesses can identify areas for improvement and refine their strategy to better meet the needs of their users.

In summary, Product-Led Sales is a powerful strategy that leverages the product's value to drive sales and customer acquisition. By focusing on user experience, offering easy access to the product, and using data to guide sales efforts, businesses can effectively convert users into loyal customers and achieve sustainable growth.

# Prototyping

Source: https://userjot.com/definitions/prototyping
Updated: 2025-01-28

> Prototyping is building an early model of a product, from paper sketch to clickable mockup, to test and refine an idea with users before full development.

Prototyping involves creating a simplified version of a product that can be used to demonstrate its functionality and design. These prototypes can range from low-fidelity sketches or paper models to high-fidelity interactive digital versions. The goal is to create a tangible representation of the product that can be tested and evaluated.

One of the main benefits of prototyping is the ability to identify and address potential issues early in the development process. By testing a prototype, product managers can gather valuable feedback from users, stakeholders, and team members. This feedback can reveal usability problems, design flaws, or gaps in the product's functionality, allowing for adjustments before significant resources are invested.

Prototyping also helps to align the team and stakeholders around a shared vision of the product. By visualizing the product through a prototype, everyone involved can better understand its features and purpose. This shared understanding can lead to more effective communication and collaboration throughout the development process.

There are several types of prototyping methods that product managers can use, depending on the project's needs and resources. Low-fidelity prototypes, such as sketches or paper models, are quick and inexpensive to create. They are useful for exploring initial ideas and getting early feedback. High-fidelity prototypes, on the other hand, are more detailed and interactive, often resembling the final product. These prototypes are valuable for testing specific functionalities and user interactions.

Incorporating prototyping into the product development process can lead to more successful outcomes. By iterating on prototypes and refining the product based on feedback, product managers can create solutions that better meet the needs of their users. Prototyping encourages a culture of experimentation and continuous improvement, helping teams to deliver high-quality products more efficiently.

In summary, prototyping is a powerful tool for product managers to test and refine product concepts before full development. By creating early models of the product, gathering feedback, and iterating on the design, teams can identify and address issues early, align stakeholders, and ultimately deliver more effective and user-friendly products.

# Scope Creep

Source: https://userjot.com/definitions/scope-creep
Updated: 2025-01-21

> Scope creep is the uncontrolled growth of a project's objectives after the plan is set, as requirements are added without adjusting time or budget.

Scope creep can arise from various sources, including unclear initial requirements, poor communication, or changing stakeholder expectations. For example, a project might start with a simple goal but then grow to include additional features or functionalities that were not part of the original plan. These changes can seem small at first but can quickly accumulate, causing a significant deviation from the project's original scope.

To control scope creep, product managers should start by clearly defining the project's objectives and deliverables. This involves creating a detailed project scope document that outlines what is included and, just as importantly, what is not included in the project. This document serves as a reference point for all stakeholders and helps to manage expectations.

Regular communication with stakeholders is critical to managing scope creep. Product managers should ensure that all stakeholders understand the project's scope and any limitations. Regular meetings and updates can help identify potential scope changes early, allowing for timely adjustments. When a change is requested, it should go through a formal change management process. This process should include an assessment of the impact of the change on the project's timeline, budget, and resources.

Another strategy to manage scope creep is to prioritize project requirements. By using techniques like the MoSCoW method (Must have, Should have, Could have, Won't have), product managers can focus on delivering the most essential features first. This approach helps keep the project aligned with its core objectives and reduces the chances of scope creep. It also allows for a more iterative approach to project delivery, where additional features can be added in subsequent phases if needed.

Product managers should also be proactive in identifying and addressing potential scope creep. This means being vigilant about changes in requirements or expectations and addressing them promptly. By being proactive, product managers can prevent small changes from turning into major scope issues.

In addition, it is important to maintain a clear record of all project changes. This record should include the reasons for the change, its impact on the project, and any adjustments made to the project plan. This record helps to track the evolution of the project and provides valuable information for future projects.

Overall, managing scope creep requires a combination of clear planning, effective communication, and a structured change management process. By employing these techniques, product managers can keep their projects focused, deliver products on time and within budget, and increase the likelihood of project success.

# Scrum Master

Source: https://userjot.com/definitions/scrum-master
Updated: 2025-01-21

> A Scrum Master is the team member who keeps a Scrum team working the Scrum way: running the sprint ceremonies, removing blockers, and shielding the team.

The Scrum Master supports the team by facilitating meetings like the Daily Scrum, Sprint Planning, Sprint Review, and Sprint Retrospective. During these meetings, the Scrum Master helps the team plan their work, review what they've done, and figure out how to improve for the next sprint. They also work to protect the team from outside interruptions, allowing the team to focus on their tasks.

One important part of the Scrum Master's role is to coach the team on Scrum values and principles. This includes promoting transparency, inspection, and adaptation within the team. The Scrum Master helps the team understand how to work together better, encouraging open communication and collaboration.

The Scrum Master also works with the Product Owner to make sure the team has a clear understanding of the product goals and priorities. They help the Product Owner manage the product backlog, ensuring that it is well-organized and prioritized according to business needs.

In addition, the Scrum Master acts as a servant-leader, meaning they focus on serving the team rather than directing it. They help the team self-organize and make decisions, fostering a culture of empowerment and accountability.

Overall, a Scrum Master plays a key role in helping a Scrum team work efficiently and effectively. By facilitating Scrum practices, removing obstacles, and coaching the team, the Scrum Master helps the team deliver value to customers and improve continuously.

# Software as a Service (SaaS)

Source: https://userjot.com/definitions/software-as-a-service-saas
Updated: 2025-01-21

> Software as a Service (SaaS) is a model where a provider hosts an application and customers use it over the internet on a subscription, nothing to install.

In a SaaS model, the provider manages all aspects of the software, including maintenance, updates, and infrastructure. This reduces the burden on the customer, who can focus on using the software rather than managing its technical details. Users typically pay a subscription fee to access the software, which can be a more affordable option compared to purchasing traditional software licenses.

One of the main benefits of SaaS is its accessibility. Users can access the software from any device with an internet connection, making it convenient for remote work and collaboration. This accessibility also allows for easier scalability, as businesses can quickly adjust their subscription plans to accommodate changes in their needs.

SaaS also offers faster deployment compared to traditional software. Since the software is already hosted and maintained by the provider, users can start using it almost immediately. This quick deployment can save time and resources, allowing businesses to focus on their core activities.

Another advantage of SaaS is that it often includes automatic updates and bug fixes. The provider ensures that the software is always up-to-date, reducing the risk of security vulnerabilities and ensuring that users have access to the latest features. This automatic update process also eliminates the need for manual updates, which can be time-consuming and disruptive.

However, SaaS also has some considerations. Since the software is hosted by a third-party, businesses rely on the provider's infrastructure and security measures. It's important to choose a reputable SaaS provider with a strong track record of reliability and security. Additionally, businesses need to ensure that the SaaS application meets their specific needs and integrates well with their existing systems.

In summary, SaaS provides a flexible and cost-effective way for businesses to access software applications. By outsourcing the management and maintenance of the software, businesses can focus on their core activities and achieve greater efficiency. While there are some considerations to keep in mind, the benefits of SaaS make it a valuable option for many organizations.

# Unsubscribe Rate

Source: https://userjot.com/definitions/unsubscribe-rate
Updated: 2025-01-28

> Unsubscribe rate is the percentage of recipients who opt out after an email: unsubscribes ÷ delivered × 100. A rise points to frequency or relevance.

The unsubscribe rate is calculated by dividing the number of unsubscribes by the total number of emails sent, then multiplying the result by 100 to get a percentage. This metric is important for businesses to monitor as it can indicate issues with the frequency, relevance, or quality of the emails being sent. A high unsubscribe rate may suggest that the content is not meeting the needs or interests of the recipients.

To manage the unsubscribe rate, businesses need to focus on delivering valuable and relevant content to their subscribers. This involves understanding the preferences and behaviors of the audience and tailoring the email content accordingly. It's also important to provide clear and easy options for unsubscribing, as this can improve the overall user experience and reduce frustration.

Another strategy to lower the unsubscribe rate is to segment the email list based on different criteria, such as interests or past interactions. By sending targeted emails to specific segments, businesses can increase the relevance of their content and reduce the likelihood of recipients opting out.

Monitoring the unsubscribe rate over time allows businesses to identify trends and make adjustments to their email marketing strategy. By analyzing which types of emails lead to higher unsubscribe rates, businesses can refine their approach and focus on creating content that keeps subscribers engaged and satisfied.

In addition to improving subscriber retention, a low unsubscribe rate can also contribute to better deliverability and engagement metrics. When fewer people unsubscribe, the email list remains more engaged and responsive, leading to higher open rates, click-through rates, and conversions.

Overall, the unsubscribe rate is a critical metric for businesses to track and optimize. By understanding what drives recipients to unsubscribe, businesses can create more effective email marketing campaigns and build stronger, more loyal relationships with their audience.

# User Acceptance Testing (UAT)

Source: https://userjot.com/definitions/user-acceptance-testing-uat
Updated: 2025-01-26

> User Acceptance Testing (UAT) is the final test phase where real end users try the software against their requirements before it is released.

User Acceptance Testing (UAT) is typically conducted after the software has passed other forms of testing, such as unit testing, integration testing, and system testing. The primary goal of UAT is to validate that the software meets the business needs and user expectations before it is released to the broader market.

During UAT, real users or representatives of the target audience interact with the software in a controlled environment. They perform tasks that reflect real-world usage scenarios to identify any issues or discrepancies between the software's functionality and their expectations. This process helps to uncover defects that might not have been detected during earlier testing phases.

UAT can take various forms depending on the project's needs. It might involve structured testing sessions where users follow predefined test cases, or it could be more exploratory, allowing users to freely interact with the software and provide feedback. In some cases, UAT might also include beta testing, where a larger group of users tests the software in a live environment before the official release.

One key aspect of UAT is the involvement of stakeholders from different parts of the organization. This can include end-users, business analysts, product managers, and other relevant parties. Their diverse perspectives help ensure that the software meets all necessary requirements and is ready for deployment.

To conduct effective UAT, it's important to have clear acceptance criteria defined from the start. These criteria should outline-solid the specific functionalities and performance levels that the software must meet to be considered acceptable. By setting these standards, the team can objectively evaluate the software's readiness and make informed decisions about its release.

Documentation plays a crucial role in UAT. Testers should record any issues they encounter, along with detailed descriptions of the problems and steps to reproduce them. This documentation helps developers address the issues and ensures that the same problems do not reoccur in future releases.

In summary, User Acceptance Testing (UAT) is a vital step in ensuring that software meets user needs and functions as intended. By involving real users in the testing process and setting clear acceptance criteria, teams can validate the software's readiness and deliver a product that aligns with business objectives and user expectations.

# User Activation

Source: https://userjot.com/definitions/user-activation
Updated: 2025-01-29

> User activation is the moment a new user first experiences a product's core value, measured by the key actions that predict they will keep using it.

User Activation begins when a new user signs up or downloads a product. The first step is to make sure the user has a smooth onboarding experience. This means providing clear instructions and a simple setup process. A good onboarding experience helps users feel comfortable and confident with the product from the start.

The next step in User Activation is to encourage users to complete key actions that demonstrate the product's value. These actions, often called activation events, can include things like sending a first message, completing a profile, or making a first purchase. By guiding users to these events, companies can show them the benefits of using the product.

To achieve User Activation, companies often use various strategies. One common approach is to send personalized emails or in-app notifications that guide users through the product. These messages can highlight key features and provide tips on how to get the most out of the product. Another strategy is to offer incentives, like discounts or rewards, to encourage users to take action.

It's important to track and measure User Activation. Companies use metrics like activation rate, which shows the percentage of new users who complete the activation events. By monitoring these metrics, companies can identify areas for improvement and adjust their activation strategies accordingly.

User Activation is not a one-time event but an ongoing process. After the initial activation, companies need to keep users engaged and encourage them to continue using the product. This can involve regular updates, new features, and continued communication to keep users interested and active.

In summary, User Activation is a critical part of turning new users into loyal customers. By providing a smooth onboarding experience, guiding users to key actions, and keeping them engaged, companies can increase user satisfaction and retention.

# User Onboarding

Source: https://userjot.com/definitions/user-onboarding
Updated: 2025-01-28

> User onboarding is the guided first experience that takes a new user from sign-up to their first success, through setup, tours, and in-product prompts.

User Onboarding starts when a new user signs up for a product or service. The first step is to welcome the user and provide a clear introduction to what the product does. This might include a welcome email or a tutorial that explains the basics.

Next, the onboarding process involves showing users how to use the product's key features. This can be done through interactive guides, tooltips, or step-by-step instructions. The goal is to help users understand how to navigate the product and perform essential tasks.

An important part of User Onboarding is helping users achieve their first successes. This might involve setting up a user's account, completing a first task, or reaching a specific milestone. By achieving these early wins, users feel more confident and are more likely to continue using the product.

User Onboarding also includes collecting feedback from new users. This feedback helps businesses understand what users like and dislike about the onboarding process, allowing them to make improvements. Surveys, user interviews, and analytics data can all be used to gather this information.

Another key aspect of User Onboarding is providing ongoing support. This might include access to help documentation, customer support, or a community forum where users can ask questions and share tips. By offering support, businesses can help users overcome any challenges they face during the onboarding process.

Effective User Onboarding can lead to higher user engagement, increased retention, and better overall user satisfaction. By guiding new users through the initial stages of using a product, businesses can ensure that users have a positive experience and are more likely to become long-term customers.

# User Persona

Source: https://userjot.com/definitions/user-persona
Updated: 2025-01-28

> A user persona is a fictional profile of a target user, built from research, that gives a team a shared picture of goals, behaviors, and pain points.

A User Persona typically starts with basic demographic details such as age, gender, occupation, and location. This information helps to create a clear picture of who the user is. For example, a persona might be a 30-year-old software developer living in a major city. These details set the stage for understanding the user's context and background.

Next, the persona includes information about the user's behaviors and habits. This might cover how they interact with technology, their preferred communication channels, and their daily routines. For instance, the software developer might spend several hours a day coding and rely heavily on online resources for problem-solving. Understanding these behaviors helps teams tailor their products to fit seamlessly into the user's life.

The goals and motivations of the user are also crucial components of a User Persona. These outline what the user hopes to achieve and what drives them. For the software developer, a goal might be to increase productivity or learn new programming languages. By identifying these goals, product teams can design features that directly address the user's needs and aspirations.

Pain points and challenges are another important aspect of a User Persona. These are the obstacles or frustrations the user faces, which the product or service aims to alleviate. The software developer might struggle with managing multiple projects or finding reliable documentation. Recognizing these pain points allows teams to focus on solutions that will make a significant difference in the user's experience.

User Personas are often created through a combination of market research, user interviews, and data analysis. They are not static documents but should be updated regularly to reflect changes in user behavior and market conditions. By using User Personas, teams can ensure that their products are user-centered and meet the needs of their target audience effectively.

In summary, User Personas are essential tools in product development and marketing. They provide a detailed and empathetic understanding of the target user, guiding teams in creating products that are relevant, useful, and engaging. By focusing on the user's demographics, behaviors, goals, and pain points, User Personas help ensure that products meet the needs and expectations of their intended audience.

# User Story

Source: https://userjot.com/definitions/user-story
Updated: 2025-01-21

> A user story is a short requirement from the user's point of view: as a [type of user], I want [an action] so that [a benefit]. Agile teams plan with them.

User stories typically follow a standard format: "As a [type of user], I want [an action] so that [a benefit/value]." For example, "As a customer, I want to be able to reset my password so that I can regain access to my account if I forget it." This format ensures that the story is centered around the user and the value they will gain from the feature.

Creating effective user stories involves several key steps. First, product managers need to identify the target users and understand their needs and pain points. This can be done through user research, interviews, and feedback sessions. Once the users' needs are clear, product managers can start writing user stories that address these needs.

Each user story should be concise and focused on a single feature or requirement. It should be written in plain language that is accessible to both technical and non-technical stakeholders. This clarity helps ensure that everyone involved in the project understands the user's needs and the intended outcome.

User stories are often accompanied by acceptance criteria, which are specific conditions that must be met for the story to be considered complete. These criteria provide a clear definition of done and help the development team understand what is expected of them. For example, acceptance criteria for the password reset story might include requirements like "The user must receive an email with a password reset link" and "The new password must meet the system's security requirements."

Prioritizing user stories is another important aspect of their use in agile development. Product managers need to assess the value and urgency of each story and arrange them in a backlog. This prioritization can be based on factors like business value, user impact, and technical feasibility. By focusing on high-priority stories first, teams can deliver the most valuable features to users as quickly as possible.

User stories are also used in sprint planning, where the development team selects a set of stories to work on during a sprint. During this process, the team breaks down the stories into tasks and estimates the effort required to complete them. This helps in planning the work and ensuring that the team can deliver the committed stories within the sprint timeframe.

Throughout the development process, user stories serve as a communication tool between product managers, developers, and other stakeholders. They facilitate discussions and help ensure that everyone is aligned on the project's goals and progress. Regular reviews and updates to user stories can help refine the product's direction and ensure that it continues to meet user needs.

In summary, user stories are a fundamental tool in agile development that help product managers and teams deliver value to users. By capturing user needs in a simple and focused way, user stories enable effective prioritization, planning, and communication throughout the development process.

# Value Proposition

Source: https://userjot.com/definitions/value-proposition
Updated: 2025-01-28

> A value proposition is a clear statement of the problem a product solves, the benefit it delivers, and why a customer should choose it over alternatives.

A Value Proposition is crucial for any business, especially for SaaS founders, founders, entrepreneurs, and developers. It serves as the foundation of a company's marketing and sales strategy, helping to attract and retain customers. A strong Value Proposition clearly articulates the unique benefits that a product or service offers, making it easier for potential customers to understand why they should choose it over other options.

Creating a Value Proposition involves identifying the key problems that the target audience faces and explaining how the product or service addresses these issues. It should highlight the specific benefits that customers will experience, such as saving time, reducing costs, or improving performance. Additionally, a Value Proposition should differentiate the product or service from competitors by emphasizing its unique features or advantages.

To develop an effective Value Proposition, businesses should conduct market research to understand their customers' needs and preferences. This involves gathering feedback from existing customers, analyzing competitor offerings, and identifying gaps in the market. Based on this research, businesses can craft a Value Proposition that resonates with their target audience and clearly communicates the value they provide.

A Value Proposition should be concise and easy to understand. It should be communicated consistently across all marketing materials, including websites, advertisements, and sales pitches. By clearly stating the benefits and unique advantages of their product or service, businesses can build trust with potential customers and increase their chances of making a sale.

In summary, a Value Proposition is a vital tool for businesses to communicate their unique value to customers. By clearly explaining how a product or service solves problems, delivers benefits, and stands out from competitors, businesses can attract and retain customers, ultimately driving growth and success.

# Adding User Feedback, Roadmap & Changelog to Your Adalo App with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-adalo
Updated: 2025-04-04

> In Adalo, add a Link action to a button or menu item to open your UserJot feedback board, public roadmap, and changelog from the app. No code, free plan.

Connect your Adalo application with UserJot to easily gather user suggestions, display your product plans, and announce updates. This guide shows you how to link UserJot's feedback board, roadmap, and changelog directly from your Adalo app.

## Why Connect UserJot to Your Adalo App?

Integrating UserJot with your Adalo app provides dedicated spaces for user interaction. You can [collect user feedback](https://userjot.com/support/getting-started) directly, showcase your development direction with a public [product roadmap](https://userjot.com/support/plan-work), and keep users informed about new features through a [changelog](https://userjot.com/support/publish-updates). This helps build community and transparency around your product development.

## Setting Up Your UserJot Features

Before linking to Adalo, you need your UserJot spaces ready.

1.  **Create a UserJot Account:** Sign up at UserJot to get started. Your project will have a default subdomain like `yourproject.userjot.com`.
2.  **Prepare Your Boards:** Set up your feedback board(s), roadmap, and changelog within UserJot.
3.  **Get Your Links:** Note the URLs for each section you want to link:
    - Feedback: `https://yourproject.userjot.com/`
    - Roadmap: `https://yourproject.userjot.com/roadmap`
    - Updates/Changelog: `https://yourproject.userjot.com/updates`
    - If using a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourcompany.com`), use those URLs instead. See the [linking guide](https://userjot.com/support/share-your-board) for examples.

## Adding UserJot Links to Your Adalo App

Adalo makes it straightforward to link external URLs from components like buttons, text, or navigation elements.

1.  **Open Your Adalo App:** Log in to Adalo and open the app editor.
2.  **Select a Component:** Choose the button, text, or list item where you want to add the UserJot link (e.g., a "Feedback" button in your app's menu or profile screen).
3.  **Add Link Action:**
    - With the component selected, find the "Actions" section in the left-hand panel.
    - Click "+ Add Action".
    - Choose the "Link" action type, then select "Website".
4.  **Enter UserJot URL:** In the "Website URL" field, paste the full URL for the desired UserJot page (e.g., `https://yourproject.userjot.com/` for the feedback board).
5.  **Configure Link Behavior (Optional):** Decide if the link should open in the Adalo web view or the device's default browser. For external sites like UserJot, opening in the default browser is often preferred.
6.  **Repeat for Other Links:** Add separate links for your roadmap and changelog using the same process with their respective URLs and appropriate components/text (e.g., a "Roadmap" button linking to `https://yourproject.userjot.com/roadmap`).
7.  **Test Your Links:** Preview your Adalo app and click the links to confirm they open the correct UserJot pages.

Use clear link text like "Share Feedback," "View Roadmap," or "See What's New" so users understand where the link leads. Placing these links in your app's settings, help section, or main navigation is common.

## Matching UserJot to Your App Design

For a cohesive user experience between your Adalo app and UserJot pages, use UserJot's customization features. Adjust your project's name, logo, favicon, and primary color in the [Branding settings](https://userjot.com/support/customize-branding). Using a [custom domain](https://userjot.com/support/custom-domain) like `feedback.yourapp.com` also reinforces your brand identity.

## Conclusion

Connecting UserJot to your Adalo app via direct links is an effective way to manage user feedback, communicate plans, and announce updates without complex integration. Start gathering valuable insights from your Adalo users today.

# How to Add User Feedback, Roadmap & Changelog to Your Bildr Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-bildr
Updated: 2025-04-04

> In Bildr, drop Link elements into your header or footer to connect a feedback board, public roadmap, and changelog. No code, free plan, about ten minutes.

Adding user feedback collection, a public product roadmap, and a changelog to your Bildr website is straightforward using UserJot. This guide shows you how to connect these features by adding direct links from your Bildr site to your UserJot pages.

## Why Connect UserJot to Your Bildr Site?

Linking UserJot to your Bildr project lets you centralize user engagement. You can:

- **Gather user suggestions:** Create a dedicated space for users to submit ideas and feedback directly through a [UserJot feedback board](https://userjot.com/support/getting-started).
- **Display your product roadmap:** Share your development plans transparently by linking to your UserJot [roadmap page](https://userjot.com/support/plan-work).
- **Publish product updates:** Announce new features and improvements using a UserJot [changelog](https://userjot.com/support/publish-updates).

## Setting Up Your UserJot Account

Before linking, you need a UserJot project set up.

1.  **Create an account:** Sign up at the [UserJot Dashboard](https://app.userjot.com). Basic boards are created automatically to help you [get started](https://userjot.com/support/getting-started).
2.  **Get your links:** UserJot provides unique URLs for your feedback board, roadmap, and updates page. These will look like `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/` if you use a [custom domain](https://userjot.com/support/custom-domain). Specific pages are found at `/roadmap` and `/updates`. Find guidance on constructing these links [here](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Bildr Site

The most common way to integrate UserJot with Bildr is by adding text links to your site's navigation bar or footer.

1.  **Open your Bildr project:** Log in to Bildr and open the project you want to edit.
2.  **Navigate to the page:** Go to the page where you want to add the links (e.g., your main layout containing the header or footer).
3.  **Add a Link Element:**
    - From the Bildr element panel, drag a 'Link' element (or a similar text/button element you intend to use as a link) onto your page canvas. Place it in your desired location (e.g., within your site footer section).
    - Alternatively, select an existing text element.
4.  **Configure the Link:**
    - Select the newly added element or the text you want to make into a link.
    - In the Bildr properties panel (usually on the right), find the 'Link' or 'URL' setting (this might be under 'Events' or 'Attributes' depending on the element type).
    - Paste the URL for your UserJot feedback board (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/`) into the appropriate field.
    - Set the display text for the link (e.g., "Share Feedback", "Suggest a Feature").
5.  **Repeat for Roadmap and Updates:** Add separate links for your UserJot roadmap (`/roadmap` path) and changelog (`/updates` path), using clear text like "Product Roadmap" or "Latest Updates".
6.  **Style the Links:** Use Bildr's styling options to make the links match your site's design.
7.  **Save and Publish:** Save your changes in Bildr and publish your site.

## Matching UserJot to Your Site Design

For a cohesive experience, customize UserJot's appearance:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the logo, project name, and primary color to match your Bildr site.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) (like `feedback.yourdomain.com`) for a fully branded look.

Adding these UserJot links gives your Bildr site users a direct way to share ideas and follow your product's progress. Start collecting feedback on your Bildr site today.

# How to Add User Feedback, Roadmap & Changelog to Your Bubble.io Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-bubble.io
Updated: 2025-04-04

> In Bubble.io, add Link elements to a reusable header or footer to connect a feedback board, public roadmap, and changelog. No plugin, free plan.

Connect your Bubble.io application with UserJot to easily gather user feedback, share your product roadmap, and announce updates. This guide shows you how to link UserJot features directly from your Bubble.io site.

## Why Connect UserJot to Your Bubble.io App?

Integrating UserJot with your Bubble.io app provides a direct channel for user interaction. You can collect user suggestions, show your development plans via a public [product roadmap](https://userjot.com/support/plan-work), and keep users informed about new features through a [changelog](https://userjot.com/support/publish-updates). It centralizes feedback management without complex Bubble development. Learn more about UserJot in the [getting started guide](https://userjot.com/support/getting-started).

## Setting Up Your UserJot Boards

Before linking from Bubble.io, you need your UserJot pages ready:

1.  Create a UserJot account and set up your project.
2.  UserJot provides a URL like `https://yourproject.userjot.com`. You can find this in your UserJot dashboard.
3.  Alternatively, set up a [custom domain](https://userjot.com/support/custom-domain) like `feedback.yourdomain.com` for a branded experience.
4.  Your core pages will be:
    - Feedback Board: `https://yourproject.userjot.com/` (or your custom domain)
    - Roadmap: `https://yourproject.userjot.com/roadmap`
    - Updates/Changelog: `https://yourproject.userjot.com/updates`
5.  See examples of how to structure these links in the [add links to footer guide](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Bubble.io Site

The most straightforward way to connect UserJot is by adding direct links to your Bubble.io application, often in a shared header or footer element.

1.  **Open Your Bubble Editor:** Log in to Bubble.io and open the application editor for the project you want to modify.
2.  **Navigate to Header/Footer (Recommended):** Go to the reusable element (like a header or footer) where you want the UserJot links to appear consistently across your site. You can also add links directly to specific pages.
3.  **Add Link Elements:**
    - From the 'Visual elements' panel on the left, drag a **Link** element onto your page or reusable element.
    - Repeat this for each UserJot section you want to link (e.g., Feedback, Roadmap, Updates).
4.  **Configure Each Link:**
    - Select a Link element.
    - In the Property Editor that appears, find the **'Link destination'** field and choose 'External URL'.
    - In the **'Destination URL'** field below, paste the full URL for the corresponding UserJot page (e.g., `https://yourproject.userjot.com/roadmap`).
    - In the **'Link text'** field, enter clear, descriptive text like "Product Roadmap", "Share Feedback", or "Latest Updates".
    - Optionally, check **'Open in a new tab'** if you want users to stay on your Bubble app.
5.  **Style the Links:** Use the 'Style' tab in the Property Editor to adjust the appearance (font, color, size) of your links to match your Bubble.io site design.
6.  **Preview:** Use Bubble's 'Preview' mode to test your links and make sure they direct users to the correct UserJot pages.

## Matching UserJot to Your Site Design

For a consistent user experience between your Bubble.io app and UserJot pages:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to upload your logo, favicon, and set a primary color that matches your Bubble app's design.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) (`feedback.yourdomain.com`) so the URL aligns with your main application domain.

## Conclusion

Adding UserJot links to your Bubble.io site provides an easy way to engage your users, gather valuable feedback, and communicate your product's direction. Start connecting with your users on your Bubble.io site today.

# How to Add User Feedback, Roadmap, and Changelog to Your Carrd Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-carrd
Updated: 2025-04-04

> On Carrd, one Links element in the footer connects a feedback board, public roadmap, and changelog: three labels, three URLs. No code, free plan.

Looking to gather user ideas, show your product plans, or announce updates on your Carrd site? This guide explains how to connect UserJot's feedback board, roadmap, and changelog features directly to your Carrd website using simple links.

## Why Connect UserJot to Your Carrd Site?

Linking UserJot lets Carrd site owners easily collect user suggestions for improvement, display a public [product roadmap](https://userjot.com/support/plan-work) showing future plans, and [publish updates](https://userjot.com/support/publish-updates) about new features or changes. It centralizes feedback and communication, keeping your audience informed. You can [get started with UserJot](https://userjot.com/support/getting-started) quickly.

## Setting Up Your UserJot Boards

First, you need your UserJot feedback, roadmap, and update pages ready.

1.  Create a free account and project on UserJot.
2.  UserJot gives you a unique subdomain like `yourproject.userjot.com`.
3.  Optionally, you can set up a [custom domain](https://userjot.com/support/custom-domain) like `feedback.yourdomain.com` for a branded look.
4.  You will link directly to these pages from your Carrd site. Find examples of how to structure these links in the [footer links guide](https://userjot.com/support/share-your-board).

Your main UserJot links will typically be:

- Feedback Board: `https://yourproject.userjot.com/` (or your custom domain)
- Roadmap: `https://yourproject.userjot.com/roadmap` (or `yourcustom.domain/roadmap`)
- Updates/Changelog: `https://yourproject.userjot.com/updates` (or `yourcustom.domain/updates`)

## Adding UserJot Links to Your Carrd Site

Carrd makes adding external links straightforward. You can add links to your site's footer, header, or main content area.

1.  **Log in to Carrd:** Open your Carrd dashboard and select the site you want to edit.
2.  **Choose Location:** Scroll to the section where you want to add the links (e.g., the bottom of your page for a footer).
3.  **Add Element:** Click the `+` icon to add a new element. Select the 'Links' or 'Buttons' element type. The 'Links' element is often better for simple text links in a footer.
4.  **Configure Links:**
    - Click on the newly added element to open its settings panel.
    - For a 'Links' element, you can add multiple links. For each link:
      - Enter the **Label** (the text users will see), for example: "Share Feedback", "Product Roadmap", "Latest Updates".
      - Paste the corresponding **URL** from your UserJot setup (e.g., `https://yourproject.userjot.com/` for the "Share Feedback" link).
    - For a 'Buttons' element, configure each button similarly with a Label and URL.
5.  **Style (Optional):** Adjust the appearance (font, size, color, spacing) of the links or buttons in the 'Appearance' tab of the settings panel to match your Carrd site design.
6.  **Save Changes:** Click 'Done' in the settings panel, then click 'Publish changes' at the top right of the Carrd editor.

## Matching UserJot to Your Site Design

For a unified look, customize UserJot's appearance using the [branding options](https://userjot.com/support/customize-branding). You can change the project name, upload your logo and favicon, and set a primary color that matches your Carrd site's style. Using a [custom domain](https://userjot.com/support/custom-domain) also helps create a seamless experience for your visitors.

## Conclusion

Adding UserJot links to your Carrd site provides a simple path for visitors to give feedback and see your progress. Start collecting feedback directly from your Carrd site visitors today.

# Add User Feedback, Roadmap, and Changelog to Your Duda Website with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-duda
Updated: 2025-04-04

> In Duda, use Edit Navigation or a footer Text widget to link a feedback board, public roadmap, and changelog. No code, free plan, about ten minutes.

Want to collect user ideas, share your product plans, or announce updates directly from your Duda website? This guide shows you how to connect UserJot to your Duda site by adding simple links.

## Why Connect UserJot to Duda?

Integrating UserJot with your Duda site provides a central place for user interaction regarding your product's development. You can:

- **Collect Feedback:** Create a [feedback board](https://userjot.com/support/getting-started) where users can post suggestions and vote on ideas.
- **Display Your Roadmap:** Share your future direction with a public [product roadmap](https://userjot.com/support/plan-work) that updates automatically based on feedback status.
- **Publish Updates:** Keep users informed about new features and improvements using a dedicated [changelog](https://userjot.com/support/publish-updates).

## Setting Up Your UserJot Project

Before linking to your Duda site, you need a UserJot project set up.

1.  [Sign up for UserJot](https://app.userjot.com) and create your project. This gives you a dedicated space like `yourproject.userjot.com`.
2.  UserJot automatically creates boards for feedback, a roadmap, and updates.
3.  You can find the direct links to these sections within your UserJot dashboard. They typically follow these patterns:
    - Feedback: `https://yourproject.userjot.com/`
    - Roadmap: `https://yourproject.userjot.com/roadmap`
    - Updates/Changelog: `https://yourproject.userjot.com/updates`
4.  If you prefer a branded experience, you can set up a [custom domain](https://userjot.com/support/custom-domain), like `feedback.yourdomain.com`. The paths (`/roadmap`, `/updates`) remain the same.
5.  For examples of how these links look, see the [footer link suggestions](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Duda Site

The most straightforward way to integrate UserJot with Duda is by adding text links to your site's navigation menu or footer.

1.  **Log in** to your Duda account and open the website editor for the site you want to modify.
2.  **Navigate to Header or Footer:**
    - **For Navigation Menu:** Hover over the header section and click the "Header" label, then choose "Edit Navigation".
    - **For Footer:** Scroll down to the bottom of your site, hover over the footer section, and click the "Footer" label.
3.  **Add Link:**
    - **Navigation:** Click "+ Add Item". Select "Website URL" or similar link option. Enter your UserJot link (e.g., `https://yourproject.userjot.com/`) in the URL field and descriptive text (e.g., "Share Feedback") in the text field. Click "Add Item".
    - **Footer:** Click the "+ Add Widget" button. Search for or select the "Text" widget. Drag it to your desired location in the footer. Click inside the text widget and type your link text (e.g., "Product Roadmap"). Highlight the text, click the "Link" icon in the text editor toolbar, choose "Website URL", paste your UserJot roadmap link (e.g., `https://yourproject.userjot.com/roadmap`), and apply the link.
4.  **Repeat for Other Links:** Add separate links for your feedback board, roadmap, and changelog as needed, using clear text like "See What's Coming" or "Latest Updates".
5.  **Save and Publish:** Use the Duda editor's options to save your changes and republish your site.

## Matching UserJot to Your Site Design

To create a consistent look between your Duda site and your UserJot pages:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the logo, project name, and primary color to match your Duda site's design.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourcompany.com`) for a fully integrated appearance.

Adding UserJot links provides a simple yet effective way to gather valuable user input and communicate product progress directly from your Duda website. Start collecting feedback on your Duda site today.

# Add User Feedback, Roadmap & Changelog to Your Framer Website

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-framer
Updated: 2025-04-04

> In Framer, link text layers in your nav or footer component to a feedback board, public roadmap, and changelog. No code, free plan, about ten minutes.

This guide explains how to connect UserJot features like feedback boards, public roadmaps, and product changelogs to your website built with Framer. Use UserJot to gather user ideas and keep your audience informed directly from your Framer site.

## Why Connect UserJot to Framer?

Connecting UserJot to your Framer site provides a direct channel for user interaction. You can gather user suggestions, display your product roadmap publicly, and publish updates about your progress. This helps build community and transparency around your product development.

- [Learn how to get started with UserJot](https://userjot.com/support/getting-started)
- [Discover how to plan your roadmap](https://userjot.com/support/plan-work)
- [See how to publish updates](https://userjot.com/support/publish-updates)

## Setting Up Your UserJot Project

Before linking to Framer, you need to set up your UserJot project.

1.  **Create a UserJot Account:** Sign up at UserJot and create your first project.
2.  **Get Your Board Links:** Once your project is ready, UserJot provides a unique URL (like `https://yourproject.userjot.com/`) for your main feedback board. Specific paths like `/roadmap` and `/updates` are available for those features.
3.  **Consider a Custom Domain:** For a branded appearance, you can set up a custom domain like `feedback.yourdomain.com`. Learn more about [custom domain setup](https://userjot.com/support/custom-domain).

Find detailed setup instructions in the [getting started guide](https://userjot.com/support/getting-started) and tips for [adding links to your site footer](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Framer Site

The most direct way to integrate UserJot with Framer is by adding links to your site's navigation menu or footer.

1.  **Open Your Framer Project:** Log in to Framer and open the project you want to edit.
2.  **Navigate to Your Navigation or Footer:** Locate the component (often a Master Component) that contains your site's navigation bar or footer section in the Layers panel. Double-click to edit it.
3.  **Select or Add Link Text:** Find an existing text link (e.g., "Feedback", "Roadmap", "What's New") or add a new text layer where you want the link to appear.
4.  **Add the Link:**
    - Select the text layer.
    - In the right-hand properties panel, find the "Link" section.
    - In the "URL" field, paste the full URL for your UserJot board, roadmap, or changelog (e.g., `https://yourproject.userjot.com/`, `https://yourproject.userjot.com/roadmap`, or your custom domain equivalent).
    - Choose whether the link should open in a new tab.
5.  **Publish Your Changes:** Preview your site to test the links. Once confirmed, publish your Framer site to make the changes live.

**Example Link Text:**

- "Share Feedback" -> `https://yourproject.userjot.com/`
- "View Roadmap" -> `https://yourproject.userjot.com/roadmap`
- "Latest Updates" -> `https://yourproject.userjot.com/updates`

## Matching UserJot to Your Site Design

Maintain a consistent look between your Framer site and UserJot pages.

- **Customize Branding:** Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the logo, favicon, and primary color to match your Framer site's design.
- **Use a Custom Domain:** Setting up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`) reinforces your brand identity.

## Conclusion

Adding UserJot links to your Framer site is a straightforward way to start collecting feedback, sharing your roadmap, and announcing updates. Connect with your users by adding these links today.

# How to Add User Feedback, Roadmap & Changelog to Your Ghost Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-ghost
Updated: 2025-04-04

> On Ghost, three links in Settings → Code Injection or the navigation add a feedback board, public roadmap, and changelog to your publication. Free plan.

Want to gather feedback, share your product plans, or announce updates directly from your Ghost publication? This guide shows you how to connect UserJot features like feedback boards, roadmaps, and changelogs to your Ghost site using simple links. UserJot offers an easy way to manage these user interactions.

## Why Connect UserJot to Your Ghost Site?

Integrating UserJot with your Ghost site lets you centralize community interaction. You can:

- **Collect User Ideas:** Create a [feedback board](https://userjot.com/support/getting-started) where readers can submit suggestions and vote on posts.
- **Display Your Plans:** Share your [product roadmap](https://userjot.com/support/plan-work) publicly, showing users what features are planned or in progress.
- **Announce Updates:** Publish a [changelog](https://userjot.com/support/publish-updates) to keep your audience informed about new developments or content updates.

## Setting Up Your UserJot Boards

Before adding links to Ghost, you need your UserJot space ready:

1.  **Create a UserJot Account:** Sign up at UserJot and set up your project. You'll get a default subdomain like `yourproject.userjot.com`. Read the [getting started guide](https://userjot.com/support/getting-started) for initial setup.
2.  **Get Your Links:** Identify the URLs for your feedback board, roadmap, and updates page.
    - Feedback: `https://yourproject.userjot.com/`
    - Roadmap: `https://yourproject.userjot.com/roadmap`
    - Updates: `https://yourproject.userjot.com/updates`
3.  **(Optional) Use a Custom Domain:** For a branded look, set up a [custom domain](https://userjot.com/support/custom-domain) like `feedback.yourdomain.com`. Your links will then use this domain (e.g., `https://feedback.yourdomain.com/roadmap`). The [footer links guide](https://userjot.com/support/share-your-board) shows examples for both subdomain and custom domain structures.

## Adding UserJot Links to Your Ghost Site

The most direct way to connect UserJot is by adding links to your Ghost site's navigation or footer. Ghost's Code Injection feature is often the simplest method.

**Method 1: Using Ghost Code Injection (Recommended for Footer Links)**

1.  **Log in** to your Ghost Admin panel.
2.  Navigate to **Settings** > **Code Injection**.
3.  In the **Site Footer** section, add HTML links. For example, to add all three links:

    ```html
    <a
      href="[https://yourproject.userjot.com/](https://yourproject.userjot.com/)"
      target="_blank"
      rel="noopener"
      >Share Feedback</a
    >
    |
    <a
      href="[https://yourproject.userjot.com/roadmap](https://yourproject.userjot.com/roadmap)"
      target="_blank"
      rel="noopener"
      >Roadmap</a
    >
    |
    <a
      href="[https://yourproject.userjot.com/updates](https://yourproject.userjot.com/updates)"
      target="_blank"
      rel="noopener"
      >Latest Updates</a
    >
    ```

    - Replace `https://yourproject.userjot.com/` with your actual UserJot board URL (or custom domain).
    - Adjust the link text (e.g., "Suggest a Feature", "See Our Plans", "What's New") to fit your site's tone.
    - You can add basic styling using `<style>` tags in the header or footer injection if needed, or rely on your theme's default link styling.

4.  Click **Save**. The links should now appear in the footer of your Ghost site.

**Method 2: Editing Your Ghost Theme (For Navigation or Specific Placement)**

If you want links in your main navigation or need more control over placement, you might need to edit your theme files (`.hbs` files):

1.  **Download** your current theme from Ghost Admin (**Settings** > **Design** > **Change theme** > **Advanced** > **Download**).
2.  **Unzip** the theme files.
3.  Locate the relevant Handlebars file (`.hbs`). This could be `partials/navigation.hbs` for the main menu or `partials/footer.hbs` / `default.hbs` for the footer, depending on your theme's structure.
4.  **Edit the file** using a code editor. Add your UserJot links using standard HTML `<a>` tags where you want them to appear within the theme's structure.
    ```html
    <a
      href="[https://yourproject.userjot.com/](https://yourproject.userjot.com/)"
      >Feedback</a
    >
    <a
      href="[https://yourproject.userjot.com/roadmap](https://yourproject.userjot.com/roadmap)"
      >Roadmap</a
    >
    <a
      href="[https://yourproject.userjot.com/updates](https://yourproject.userjot.com/updates)"
      >Updates</a
    >
    ```
5.  **Save** the changes.
6.  **Zip** the theme folder again.
7.  **Upload** the modified theme back to Ghost (**Settings** > **Design** > **Change theme** > **Advanced** > **Upload theme**).

**Tips for Adding Links:**

- Use clear link text like "Share Feedback," "View Roadmap," or "Product Updates."
- Place links where users can easily find them, such as the site footer or a dedicated "Feedback" section in your navigation.
- Test the links after adding them to make sure they go to the correct UserJot pages.

## Matching UserJot to Your Site Design

To create a cohesive experience when users click from your Ghost site to UserJot:

- **Customize Branding:** Use UserJot's [branding options](https://userjot.com/support/customize-branding) to upload your logo, favicon, and set a primary color that matches your Ghost site's design.
- **Use a Custom Domain:** Setting up a [custom domain](https://userjot.com/support/custom-domain) reinforces your brand identity when users visit your UserJot pages.

## Conclusion

Adding UserJot links to your Ghost site provides a simple yet effective way to engage your audience, gather valuable feedback, and communicate your product's direction. Start collecting feedback on your Ghost site today.

# How to Add User Feedback, Roadmap & Changelog to Your Glide App with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-glide
Updated: 2025-04-04

> In Glide, an Open Link action on a tab, button, or text component opens your feedback board, public roadmap, and changelog in the app. No code, free plan.

Want to collect user ideas, share your product plans, or announce updates directly from your Glide application? This guide explains how to connect UserJot to your Glide app by adding simple links, giving your users easy access to feedback boards, roadmaps, and changelogs.

## Why Connect UserJot to Your Glide App?

Integrating UserJot with your Glide app offers several advantages. You can centralize [user feedback collection](https://userjot.com/support/getting-started), making it simple for users to submit suggestions and vote on ideas. Displaying a public [product roadmap](https://userjot.com/support/plan-work) keeps users informed about what features are planned or in progress. Announcing [product updates](https://userjot.com/support/publish-updates) through a changelog lets users know about new features and improvements as they happen.

## Setting Up Your UserJot Account

Before linking to Glide, you need a UserJot account and project.

1.  [Sign up for UserJot](https://userjot.com/support/getting-started) (a free plan with core features is available).
2.  UserJot will create an initial project for you, accessible via a subdomain like `https://yourproject.userjot.com`.
3.  Note your UserJot URLs. The main page is your feedback board. For the roadmap, add `/roadmap` to the end. For updates, add `/updates`.
4.  (Optional) For a branded look, consider setting up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`). You can find examples of the full URLs in the [footer links guide](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Glide App

The most direct way to integrate UserJot with Glide is by adding links within your app's interface. You can place these links in navigation menus, buttons, or text elements.

Here’s a general process for adding UserJot links in the Glide editor:

1.  **Open your Glide App:** Log in to Glide and open the app you want to edit.
2.  **Choose a Location:** Decide where you want to add the links. Common places include:
    - **Navigation Bar/Tab:** Add a new tab or item pointing to your UserJot page.
    - **Button Component:** Add a button specifically for feedback or roadmap.
    - **Text/Rich Text Component:** Embed links within descriptive text.
3.  **Configure the Link Action:**
    - Select the component (tab, button, text).
    - Find the 'Action' or 'Link' setting for that component.
    - Choose an action like 'Open Link', 'Open Web View', or similar.
    - Paste the full URL for your UserJot Feedback Board (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/`).
    - Repeat this process for separate links to your Roadmap (`.../roadmap`) and Changelog (`.../updates`), if desired. Use clear link text like "Share Feedback", "View Roadmap", or "Latest Updates".

4.  **Publish Changes:** Save and publish your Glide app updates.
5.  **Test:** Open your live Glide app and test the links to confirm they open the correct UserJot pages.

## Matching UserJot to Your App Design

To create a consistent experience between your Glide app and UserJot pages, utilize UserJot's customization features.

- Adjust the [project name, logo, favicon, and primary color](https://userjot.com/support/customize-branding) in UserJot's branding settings to match your Glide app's appearance.
- Using a [custom domain](https://userjot.com/support/custom-domain) reinforces your brand identity.

## Conclusion

Connecting UserJot to your Glide app via direct links provides a straightforward way to gather feedback, communicate plans, and share updates. Start collecting feedback and engaging your users on your Glide app today.

# How to Add User Feedback, Roadmaps & Changelogs to Your GoDaddy Website Builder Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-godaddy
Updated: 2025-04-04

> In GoDaddy Website Builder, link footer or header text to a feedback board, public roadmap, and changelog. No code, free plan, about ten minutes.

Want to gather customer ideas, share your product plans, or announce updates directly on your GoDaddy Website Builder website? This guide shows you how to connect UserJot features like feedback boards, roadmaps, and changelogs to your GoDaddy site using simple links.

## Why Connect UserJot to Your GoDaddy Site?

Connecting UserJot to your GoDaddy website provides dedicated spaces for user interaction. You can create a [feedback board](https://userjot.com/support/getting-started) to collect user suggestions and votes, display your [product roadmap](https://userjot.com/support/plan-work) to show what's coming next, and [publish updates](https://userjot.com/support/publish-updates) about new features or changes. This helps keep your audience informed and engaged with your product's development directly from your GoDaddy site.

## Setting Up Your UserJot Boards

Before adding links to GoDaddy, you need your UserJot spaces ready.

1.  **Create a UserJot Account:** If you haven't already, sign up at UserJot. A basic project with starter boards is created automatically. Follow the [getting started guide](https://userjot.com/support/getting-started) for initial setup.
2.  **Find Your UserJot URLs:** UserJot hosts your feedback board, roadmap, and updates page at unique URLs.
    - If using a UserJot subdomain, your links will look like `https://yourproject.userjot.com/`, `https://yourproject.userjot.com/roadmap`, and `https://yourproject.userjot.com/updates`.
    - If you've set up a [custom domain](https://userjot.com/support/custom-domain), your links will use that, such as `https://feedback.yourdomain.com/`, `https://feedback.yourdomain.com/roadmap`, and `https://feedback.yourdomain.com/updates`.
3.  **Prepare Your Links:** Copy the specific URLs for the UserJot pages you want to link from your GoDaddy site. See examples in the [adding links guide](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your GoDaddy Website Builder Site

GoDaddy Website Builder makes adding external links straightforward, often in the site footer or navigation menu.

1.  **Log in to GoDaddy:** Access your GoDaddy account and open the Website Builder for the site you want to edit.
2.  **Edit Footer or Header:** Navigate to the section where you want to add the links. The footer is a common place for feedback or roadmap links. Click within the footer (or header/navigation area) to open its editing options.
3.  **Add or Edit Text:**
    - **New Link:** Add a new text block or button element where you want the link to appear.
    - **Existing Text:** Select the text you want to turn into a link (e.g., "Share Feedback", "View Roadmap", "Latest Updates").
4.  **Insert the Link:** Look for a link icon (usually looks like a chain) in the text editing toolbar. Click it.
5.  **Configure the Link:**
    - In the link options, choose "Website URL" or similar.
    - Paste the UserJot URL (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/roadmap`) into the URL field.
    - Consider checking the box to "Open link in new window" so visitors don't navigate away from your main site.
    - Confirm or save the link.
6.  **Repeat for Other Links:** Add links for your roadmap and changelog/updates page following the same steps.
7.  **Publish Changes:** Once you've added your links, preview your site. When satisfied, publish the changes to make the UserJot links live on your GoDaddy website.

## Matching UserJot to Your Site Design

For a more integrated feel, customize UserJot's appearance.

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the project name, upload your logo and favicon, and set a primary color that matches your GoDaddy site's design.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`) for a fully branded experience.

## Conclusion

Adding UserJot links to your GoDaddy Website Builder site connects your audience directly to your feedback channels and development progress. Start collecting feedback and sharing updates on your GoDaddy site today.

# How to Add User Feedback, Roadmap & Changelog to Your Google Sites

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-google-sites
Updated: 2025-04-04

> On Google Sites, linked text in the footer or navigation connects a feedback board, public roadmap, and changelog. No code, free plan, about ten minutes.

This guide shows you how to connect UserJot's user feedback, product roadmap, and changelog features to your Google Sites website. Use UserJot to easily gather ideas and communicate plans with your audience directly from your Google Site.

## Why Connect UserJot to Google Sites?

Integrating UserJot with your Google Sites page offers several advantages. You can create dedicated spaces to [gather user suggestions and ideas](https://userjot.com/support/getting-started) using a feedback board. Displaying your [product roadmap](https://userjot.com/support/plan-work) lets visitors see upcoming features and project direction. You can also efficiently [publish updates and announcements](https://userjot.com/support/publish-updates) through a changelog, keeping users informed about progress.

## Setting Up Your UserJot Boards

Before linking to Google Sites, you need your UserJot spaces ready.

1.  [Create a free UserJot account](https://userjot.com/support/getting-started) if you haven't already. UserJot sets up initial boards for feedback, roadmap, and updates.
2.  Your boards will be accessible via a UserJot subdomain (like `yourproject.userjot.com`).
3.  Optionally, you can set up a [custom domain](https://userjot.com/support/custom-domain) (like `feedback.yourdomain.com`) for a more branded experience.
4.  Locate the URLs for your feedback board (`/`), roadmap (`/roadmap`), and updates page (`/updates`). You will use these links in Google Sites. See [examples of how to structure these links](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Google Sites Site

The simplest way to integrate UserJot is by adding direct links to your Google Sites navigation or footer.

1.  **Open Your Google Site:** Log in to Google Sites and open the site you want to edit.
2.  **Choose Link Location:** Decide where you want the links to appear. Common places include the site footer or the main navigation menu.
3.  **Add Links to Footer (Example):**
    - Scroll to the bottom of your page where the footer area is. If you don't have one, you might need to add it via site settings or by inserting a text box at the bottom of every page.
    - Click into the footer area to edit it, or insert a new "Text box" using the "Insert" panel on the right.
    - Type the text for your links, for example:
      - "Share Feedback"
      - "View Roadmap"
      - "Latest Updates"
    - Highlight the text for the first link (e.g., "Share Feedback").
    - Click the "Insert link" icon (looks like a chain link) in the text formatting toolbar.
    - Paste the URL for your UserJot feedback board (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/`).
    - Click "Apply".
    - Repeat this process for your Roadmap (`/roadmap`) and Updates (`/updates`) links.

4.  **Add Links to Navigation:**
    - Click the "Pages" tab in the panel on the right.
    - Hover over the "+" button at the bottom and select "New link".
    - Paste the URL for your UserJot feedback board in the "Link" field.
    - Enter the link text (e.g., "Feedback") in the "Name" field.
    - Click "Done".
    - Repeat for Roadmap and Updates links. The new links will appear in your site's navigation bar.
5.  **Publish:** Click the "Publish" button in the top right corner of Google Sites to make your changes live.

## Matching UserJot to Your Site Design

For a consistent look between your Google Site and UserJot pages:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the project name, upload your logo/favicon, and set a primary color that matches your Google Site's theme.
- Consider using a [custom domain](https://userjot.com/support/custom-domain) so users see your own URL (e.g., `feedback.yourdomain.com`) when they click the links.

## Conclusion

Connecting UserJot links to your Google Sites page provides a straightforward way to collect user input and share your product's direction. Start collecting feedback on your Google Sites site today.

# How to Add User Feedback, Roadmap & Changelog to Your SITE123 Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-site123
Updated: 2025-04-04

> On SITE123, External Link pages in the header or footer links connect a feedback board, public roadmap, and changelog. No code, free plan, ten minutes.

Want to collect user ideas, share your product plans, or announce updates directly from your SITE123 website? This guide explains how to connect UserJot to your SITE123 site by adding simple links, providing dedicated pages for feedback, your roadmap, and a changelog.

## Why Connect UserJot to SITE123?

Integrating UserJot with your SITE123 site offers several advantages:

- **Gather User Suggestions:** Create a dedicated [feedback board](https://userjot.com/support/getting-started) where visitors can submit ideas and vote on existing ones.
- **Display Your Product Roadmap:** Use UserJot's [roadmap feature](https://userjot.com/support/plan-work) to show customers what features are planned, in progress, or completed.
- **Publish Updates:** Keep users informed about new features and improvements using a clean [changelog](https://userjot.com/support/publish-updates).

Adding these features helps build community, increases transparency, and gathers valuable insights for your product directly from your SITE123 audience.

## Setting Up Your UserJot Boards

Before linking from SITE123, you need your UserJot pages ready:

1.  **Create a UserJot Account:** If you haven't already, sign up at UserJot. Your project will get a default subdomain like `yourproject.userjot.com`. See the [getting started guide](https://userjot.com/support/getting-started) for initial setup.
2.  **Get Your Links:** Note the URLs for your main feedback board (`https://yourproject.userjot.com/`), roadmap (`/roadmap`), and updates page (`/updates`).
3.  **(Optional) Use a Custom Domain:** For a branded look, you can set up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`). If you do, use these URLs instead. Find examples in the [adding links guide](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your SITE123 Site

You can easily add links to your UserJot pages in your SITE123 website's navigation menu or footer.

**Method 1: Adding to the Header Navigation**

1.  Log in to your SITE123 account and open the Website Editor.
2.  Go to the **Pages** tab on the left sidebar.
3.  Click the **Add New Page** button.
4.  Select the **Link** page type.
5.  Choose **External Link**.
6.  In the **Link Text** field, enter clear text like "Share Feedback", "Product Roadmap", or "Latest Updates".
7.  In the **URL** field, paste the corresponding UserJot link (e.g., `https://yourproject.userjot.com/` or `https://yourproject.userjot.com/roadmap`).
8.  Click **Save**.
9.  You can drag the new link in the Pages list to reorder its position in your site's main menu.
10. Repeat for each UserJot page (Feedback, Roadmap, Updates) you want to link.

**Method 2: Adding to the Footer**

1.  In the SITE123 Website Editor, scroll down to the bottom of your site preview.
2.  Hover over the footer area and click **Edit**.
3.  You can often add text directly to the footer content areas. Find a suitable spot and type your link text (e.g., "Give Feedback | Our Roadmap | What's New").
4.  Select the text you just typed.
5.  Click the **Link** icon in the text editor toolbar.
6.  Choose **External Link**.
7.  Paste the appropriate UserJot URL.
8.  Click **Save** or **Apply**.
9.  Repeat for other links as needed.

**Tips for Links:**

- Use clear, action-oriented text (e.g., "Suggest a Feature", "See Our Plans").
- Place links where users expect them, like the main navigation or footer.
- Check that your links work correctly after publishing your SITE123 site changes.

## Matching UserJot to Your Site Design

For a consistent experience, customize UserJot's appearance:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to upload your logo, favicon, and set a primary color that matches your SITE123 site.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) so the URL feels like part of your main website (e.g., `feedback.yoursite123site.com`).

## Conclusion

Connecting UserJot to your SITE123 website via direct links is a straightforward way to engage your audience. Start collecting valuable feedback and sharing your progress on your SITE123 site today.

# How to Add User Feedback, Roadmap & Changelog Features to Your Softr Site

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-softr
Updated: 2025-04-04

> In Softr, menu items in the Header block or links in the Footer block connect a feedback board, public roadmap, and changelog. No code, free plan.

Want to gather customer ideas, share your product plans, and announce updates directly from your Softr website? This guide shows you how to connect UserJot to your Softr application by adding simple links, making it easy for users to engage with your feedback process.

## Why Connect UserJot to Your Softr Application?

Integrating UserJot with your Softr site provides dedicated spaces for interaction. You can:

- **Collect user suggestions:** Create a [feedback board](https://userjot.com/support/getting-started) where users can post ideas and vote on submissions.
- **Display your product roadmap:** Show users what you're planning and working on using UserJot's [roadmap feature](https://userjot.com/support/plan-work).
- **Publish product updates:** Keep everyone informed about new releases and improvements with a dedicated [changelog](https://userjot.com/support/publish-updates).

## Setting Up Your UserJot Account

Before adding links to Softr, you need your UserJot spaces ready:

1.  [Sign up for UserJot](https://app.userjot.com) and create your first project. UserJot sets up initial boards for you.
2.  Your feedback board, roadmap, and changelog will be available at a UserJot subdomain (e.g., `yourproject.userjot.com`) or you can set up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`).
3.  Note down the specific URLs for your feedback board (`/`), roadmap (`/roadmap`), and updates page (`/updates`). Find examples in the [footer links guide](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Softr Site

The most direct way to integrate UserJot with Softr is by adding text links to your site's navigation or footer.

**Steps for Softr:**

1.  **Log in** to your Softr Studio.
2.  **Navigate** to the page where you want to add the links (e.g., your homepage or a dedicated feedback page).
3.  **Identify the Block:** Locate the Header block (for navigation links) or a Footer block where you want the UserJot links to appear. Click on the block to open its settings panel.
4.  **Add or Edit Links:**
    - **Header:** Look for the "Links" or "Menu Items" section. Click "Add Item" or edit an existing one. Enter the desired text (e.g., "Share Feedback", "Roadmap", "Updates") in the "Label" or "Text" field. In the "Link" or "URL" field, paste the corresponding UserJot URL (`https://yourproject.userjot.com/`, `https://yourproject.userjot.com/roadmap`, or `https://yourproject.userjot.com/updates`, using your actual subdomain or custom domain). Set the link to open in a "New Tab" if desired.
    - **Footer:** Footer blocks often contain text elements. You might need to edit a Rich Text element within the footer block. Select the text you want to turn into a link (e.g., "Give Feedback"), use the text editor's link icon, and paste the appropriate UserJot URL.
5.  **Repeat** for each UserJot section you want to link (Feedback, Roadmap, Updates).
6.  **Publish** your Softr site changes.

**Example Link Text:**

- "Share Your Ideas" (links to `https://yourproject.userjot.com/`)
- "See Our Roadmap" (links to `https://yourproject.userjot.com/roadmap`)
- "Latest Updates" (links to `https://yourproject.userjot.com/updates`)

## Matching UserJot to Your Site Design

For a unified look, customize UserJot's appearance:

- Use UserJot's [branding settings](https://userjot.com/support/customize-branding) to upload your logo, favicon, and set your primary brand color.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) (like `feedback.yourdomain.com`) so the URL matches your main Softr site address.

## Conclusion

Adding UserJot links to your Softr navigation or footer is a straightforward way to integrate powerful feedback, roadmap, and changelog tools. Start collecting valuable user input on your Softr site today.

# How to Add User Feedback, Roadmap & Changelog to Your Squarespace Site

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-squarespace
Updated: 2025-04-04

> On Squarespace, Link items in Main or Footer Navigation under Pages connect a feedback board, public roadmap, and changelog. No code, free plan.

This guide shows you how to connect UserJot features like feedback boards, public roadmaps, and product changelogs to your Squarespace website. By adding simple links, you can easily integrate these tools without complex code.

## Why Connect UserJot to Squarespace?

Connecting UserJot to your Squarespace site provides a dedicated space for users to interact with your product development. You can:

- **Gather user suggestions:** Collect ideas and feedback directly from your visitors through a [UserJot feedback board](https://userjot.com/support/getting-started).
- **Display your product roadmap:** Share your future plans and development progress using a [public roadmap](https://userjot.com/support/plan-work).
- **Publish updates:** Announce new features and improvements with a dedicated [changelog](https://userjot.com/support/publish-updates).

## Setting Up Your UserJot Board

Before linking to your Squarespace site, you need a UserJot project.

1.  **Create a UserJot Account:** Sign up at UserJot and create your first project. This automatically generates your feedback board, roadmap, and changelog pages.
2.  **Get Your Links:** Your UserJot pages are available at a unique subdomain (e.g., `https://yourproject.userjot.com/`) or a [custom domain](https://userjot.com/support/custom-domain) you configure (e.g., `https://feedback.yourdomain.com/`).
    - Feedback Board: `https://yourproject.userjot.com/`
    - Roadmap: `https://yourproject.userjot.com/roadmap`
    - Changelog/Updates: `https://yourproject.userjot.com/updates`
    - (Replace `yourproject.userjot.com` with your actual UserJot URL or custom domain).
3.  Refer to the [getting started guide](https://userjot.com/support/getting-started) for initial setup details and the [footer links example](https://userjot.com/support/share-your-board) for link structure.

## Adding UserJot Links to Your Squarespace Site

The most common way to integrate UserJot with Squarespace is by adding direct links to your site's navigation (header or footer).

1.  **Log in to Squarespace:** Access your Squarespace account dashboard.
2.  **Go to Website:** In the main menu, click on "Website".
3.  **Navigate to Pages:** In the Website panel, find the "Pages" section.
4.  **Choose Navigation Area:** Decide where you want the link (e.g., "Main Navigation" for the header, or a "Footer Navigation" section if you have one set up). Click the `+` icon next to the chosen navigation area.
5.  **Select "Link":** From the menu that appears, choose the "Link" option.
6.  **Configure the Link:**
    - **Link Title:** Enter the text you want displayed (e.g., "Feedback", "Roadmap", "What's New").
    - **Link:** Click the gear icon next to the Link field. Select "Web Address". Paste the full URL to your UserJot board, roadmap, or changelog page (e.g., `https://yourproject.userjot.com/roadmap`).
    - **Open in New Window:** Consider checking this box so users don't navigate away from your main Squarespace site.
    - Click "Save".
7.  **Position the Link:** Drag the new link item within the navigation list to your preferred position.
8.  **Save Changes:** Squarespace usually saves automatically, but ensure your changes are reflected on your live site.

You can repeat these steps to add links for your feedback board, roadmap, and changelog separately. You can also add these links within Text Blocks in your page content or site footer if preferred.

## Matching UserJot to Your Site Design

For a more integrated look, customize UserJot's appearance:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the logo, project name, and primary color to match your Squarespace site's design.
- Set up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`) so the UserJot pages feel like a natural part of your website.

## Conclusion

Adding UserJot links to your Squarespace navigation or footer is a straightforward way to start collecting feedback, sharing your roadmap, and announcing updates. Start collecting feedback on your Squarespace site today.

# How to Add UserJot Feedback and Roadmap Links to Your Strikingly Site

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-strikingly
Updated: 2025-04-04

> On Strikingly, Settings → Navigation → Add New Link, or linked footer text, connects a feedback board, public roadmap, and changelog. No code, free plan.

Want to gather user ideas and share product plans directly from your Strikingly website? UserJot provides simple tools for feedback boards, product roadmaps, and changelogs that you can easily connect to your Strikingly site using direct links. This guide explains how to integrate these features.

## Why Connect UserJot to Your Strikingly Site?

Linking UserJot from your Strikingly website provides clear benefits. You can centralize user suggestions and ideas using a dedicated [feedback board](https://userjot.com/support/getting-started). Displaying your [product roadmap](https://userjot.com/support/plan-work) keeps users informed about upcoming features. Announcing new features through a [changelog](https://userjot.com/support/publish-updates) helps maintain user engagement.

## Setting Up Your UserJot Project

Before adding links to Strikingly, you need to set up your feedback board, roadmap, and changelog in UserJot.

1.  [Create your UserJot account](https://userjot.com/support/getting-started) and set up your first project.
2.  UserJot will provide you with unique URLs for your feedback board, roadmap (`/roadmap`), and updates page (`/updates`). These will typically be on a UserJot subdomain (e.g., `https://yourproject.userjot.com/`).
3.  Optionally, you can configure a [custom domain](https://userjot.com/support/custom-domain) (e.g., `https://feedback.yourdomain.com/`) for a more branded experience.
4.  Decide on the link text you want to use on your Strikingly site (e.g., "Share Feedback", "Product Roadmap", "What's New"). You can find examples in the [footer link guide](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Strikingly Site

The most direct way to integrate UserJot with Strikingly is by adding links to your site's navigation menu or footer.

1.  **Log in** to your Strikingly account and open the editor for the site you want to modify.
2.  **Navigate to Navigation or Footer:**
    - **For Navigation:** Go to the 'Settings' panel (usually on the left), then select 'Navigation'. Click 'Add New Link'.
    - **For Footer:** Scroll down to the bottom of your page and click to edit the footer section. You might need to add or edit a text element within the footer columns.
3.  **Configure the Link:**
    - In the link settings (whether in Navigation or editing footer text), paste the full URL to your UserJot feedback board (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/`).
    - Enter the clear link text you decided on earlier (e.g., "Share Feedback").
    - Choose if you want the link to open in a new tab (recommended for external links).
4.  **Repeat for Roadmap and Updates:** Follow the same steps to add separate links for your UserJot Roadmap (e.g., `https://yourproject.userjot.com/roadmap`) and Updates/Changelog (e.g., `https://yourproject.userjot.com/updates`), using appropriate link text like "Roadmap" or "Latest Updates".
5.  **Save and Publish:** Save your link changes within the Navigation or Footer settings. Click 'Publish' in the Strikingly editor to make the changes live on your website.

6.  **Test the Links:** Visit your live Strikingly site and test each link to confirm it correctly directs users to your UserJot pages.

## Matching UserJot to Your Site Design

For a cohesive user experience, align your UserJot pages with your Strikingly site's look and feel.

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to upload your logo and set a primary color that matches your website's design.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) so users stay within your brand's web presence when viewing feedback or the roadmap.

## Conclusion

Adding UserJot links to your Strikingly navigation or footer gives your visitors a straightforward path to share feedback, view your plans, and see product updates. Start collecting valuable input on your Strikingly site today.

# How to Add User Feedback, Roadmap & Changelog to Your Webflow Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-webflow
Updated: 2025-04-04

> In Webflow, Text Link elements in the Designer navbar or footer connect a feedback board, public roadmap, and changelog. No code, free plan, ten minutes.

Want to collect user ideas, share your product plans, or announce updates directly from your Webflow website? This guide explains how to easily connect UserJot features like feedback boards, roadmaps, and changelogs to your Webflow site by adding simple text links. UserJot provides the tools to manage this user engagement.

## Why Connect UserJot to Your Webflow Site?

Integrating UserJot with your Webflow site allows you to centralize user interaction. You can:

- **Gather user suggestions:** Create a dedicated space for users to submit feedback and ideas using a UserJot [feedback board](https://userjot.com/support/getting-started).
- **Display your product roadmap:** Show users what features are planned or in progress using UserJot's [roadmap](https://userjot.com/support/plan-work) feature.
- **Publish updates:** Keep users informed about new releases and improvements through a UserJot [changelog](https://userjot.com/support/publish-updates).

Linking these UserJot pages from your Webflow site makes them easily accessible to your audience.

## Setting Up Your UserJot Project

Before adding links to Webflow, you need your UserJot pages ready.

1.  [Sign up for UserJot](https://userjot.com/support/getting-started) and create your project.
2.  UserJot will give you a default subdomain (e.g., `yourproject.userjot.com`). You can find the links to your feedback board, roadmap (`/roadmap`), and updates page (`/updates`) from your UserJot dashboard.
3.  Optionally, set up a [custom domain](https://userjot.com/support/custom-domain) (like `feedback.yourdomain.com`) for a branded experience.
4.  Decide where you want to place the links on your Webflow site (common places are the footer or main navigation). See [examples of footer links](https://userjot.com/support/share-your-board).

You will need the direct URLs for your UserJot Feedback Board, Roadmap, and Updates pages.

## Adding UserJot Links to Your Webflow Site

Connecting UserJot to Webflow involves adding text links within the Webflow Designer. Here’s how you can add links to your site's navigation or footer:

1.  **Open Webflow Designer:** Log in to your Webflow account and open the project you want to edit in the Designer view.
2.  **Navigate to Footer/Navbar:** Scroll to the footer section or select the navigation bar where you want to add the links.
3.  **Add Link Element:**
    - From the "Add Elements" panel (shortcut 'A'), drag a **Text Link** element or a **Link Block** (if you want more complex styling) into your chosen section (e.g., within a footer column or navbar menu).
4.  **Configure the Link:**
    - Select the newly added link element.
    - Go to the **Settings** panel (shortcut 'D').
    - Under "Link Settings", choose the "URL" option.
    - Paste the full URL for your UserJot Feedback Board (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/`).
    - **Set Link Text:** Double-click the link element on the canvas and type clear, descriptive text like "Share Feedback", "Suggest an Idea", or "Give Feedback".
5.  **Repeat for Roadmap and Updates:** Repeat steps 3 and 4 to add separate links for your UserJot Roadmap (e.g., `https://yourproject.userjot.com/roadmap`) with text like "View Roadmap" or "Product Plans", and your Changelog/Updates page (e.g., `https://yourproject.userjot.com/updates`) with text like "Latest Updates" or "What's New".

6.  **Style the Links:** Use the Style panel (shortcut 'S') in Webflow to adjust the appearance (color, font, spacing) of your new links to match your site's design.
7.  **Publish Changes:** Click the "Publish" button in the top right corner of the Webflow Designer to make your changes live.

Your Webflow site now includes direct links for users to access your UserJot feedback board, roadmap, and updates.

## Matching UserJot to Your Site Design

For a consistent look between your Webflow site and your UserJot pages, consider:

- **Customizing Branding:** Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the logo, colors, and project name to align with your Webflow site's style.
- **Using a Custom Domain:** Setting up a [custom domain](https://userjot.com/support/custom-domain) reinforces your brand identity when users click the links.

## Conclusion

By adding direct links in Webflow, you can effectively integrate UserJot's feedback, roadmap, and changelog features, creating a valuable channel for user communication. Start collecting feedback and sharing updates on your Webflow site today.

# How to Add User Feedback and a Product Roadmap to Your Weebly Site

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-weebly
Updated: 2025-04-04

> On Weebly, drop a Text element in the footer and link three words to a feedback board, public roadmap, and changelog. No code, free plan, ten minutes.

Easily connect your Weebly website with user feedback tools. This guide shows you how to add links to UserJot for collecting suggestions, displaying your product roadmap, and sharing updates directly from your Weebly site.

## Why Connect UserJot to Weebly?

Integrating UserJot with your Weebly site provides a straightforward way to interact with your audience. You can:

- [Gather user suggestions](https://userjot.com/support/getting-started) and ideas through a dedicated feedback board.
- [Display your product roadmap](https://userjot.com/support/plan-work) publicly, showing users what features are planned or in progress.
- [Publish updates](https://userjot.com/support/publish-updates) and changelogs to keep visitors informed about new developments.

## Setting Up UserJot

Before adding links to Weebly, you need a UserJot account and board.

1.  Visit UserJot and [create a free account](https://userjot.com/support/getting-started). UserJot sets up initial boards for you.
2.  Your feedback board, roadmap, and updates page will be accessible via a UserJot subdomain (e.g., `yourproject.userjot.com`) or a [custom domain](https://userjot.com/support/custom-domain) you configure (e.g., `feedback.yourcompany.com`).
3.  Note the URLs for your feedback board (`/`), roadmap (`/roadmap`), and updates page (`/updates`). See examples in the [footer links guide](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Weebly Site

The simplest way to integrate UserJot is by adding direct links to your Weebly site's navigation menu or footer. Here’s how to add links to your Weebly footer:

1.  **Log in** to your Weebly Site Editor.
2.  Scroll down to the **footer area** of your website preview.
3.  From the left-hand build panel, find the **"Text" element**.
4.  **Drag and drop** the "Text" element into your desired location within the footer section.
5.  **Click** inside the newly added text box.
6.  Type the text for your link (e.g., "Share Feedback," "Product Roadmap," "Latest Updates").
7.  **Highlight** the text you just typed.
8.  Click the **link icon** (looks like a chain) in the text formatting toolbar that appears.
9.  Select **"Website URL"**.
10. **Paste** the URL for your UserJot feedback board (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourcompany.com/`).
11. Check "Open link in a new window" if desired.
12. Click **Save** or outside the link editor.
13. **Repeat** steps 6-12 for your Roadmap (`/roadmap`) and Updates (`/updates`) links.
14. **Publish** your Weebly site for the changes to go live.

You can use a similar process to add links to other text areas or use the "Pages" tab > "Add" > "External Page" option to add links directly to your main navigation menu.

## Matching UserJot to Your Site Design

For a cohesive look between your Weebly site and UserJot pages:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to upload your logo, favicon, and set a primary color matching your Weebly site's design.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourcompany.com`) so the URL aligns with your main Weebly domain.

## Conclusion

Adding UserJot links to your Weebly site provides a valuable channel for user communication. Start collecting feedback and sharing your progress on your Weebly site today.

# How to Add User Feedback, Roadmap & Changelog to Your Wix Site

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-wix
Updated: 2025-04-04

> In Wix, Manage Menu → Add Menu Item → Link, or linked footer text, connects a feedback board, public roadmap, and changelog. No code, free plan.

This guide explains how to connect UserJot features like feedback boards, public roadmaps, and product changelogs to your website built with Wix. Using UserJot, you can easily add these tools by linking directly from your Wix site's navigation or footer.

## Why Connect UserJot to Your Wix Website?

Integrating UserJot with your Wix site offers several advantages for engaging your audience. You can:

- **Gather user suggestions:** Create a dedicated space for visitors to submit ideas and feedback directly through a UserJot [Feedback Board](https://userjot.com/support/getting-started).
- **Display your product roadmap:** Share your development plans transparently using a UserJot [Roadmap](https://userjot.com/support/plan-work), showing users what features are planned or in progress.
- **Publish updates:** Announce new features, improvements, or fixes using a UserJot [Changelog](https://userjot.com/support/publish-updates), keeping your audience informed.

## Setting Up Your UserJot Project

Before adding links to Wix, you need a UserJot project.

1.  **Create a UserJot Account:** Sign up at UserJot and set up your first project. Follow the [getting started guide](https://userjot.com/support/getting-started) for initial setup.
2.  **Get Your UserJot Links:** Once your project is ready, UserJot provides a unique URL (like `https://yourproject.userjot.com/`). You can also set up a [custom domain](https://userjot.com/support/custom-domain) (like `https://feedback.yourdomain.com/`).
3.  **Identify Specific Page Links:**
    - Feedback Board: `https://yourproject.userjot.com/` (or your custom domain)
    - Roadmap: `https://yourproject.userjot.com/roadmap` (or `/roadmap` on your custom domain)
    - Changelog/Updates: `https://yourproject.userjot.com/updates` (or `/updates` on your custom domain)
    - Refer to the [guide on adding links](https://userjot.com/support/share-your-board) for examples.

## Adding UserJot Links to Your Wix Site

The most direct way to integrate UserJot with Wix is by adding text links to your site's navigation menu (header) or footer.

1.  **Log in to Wix:** Access your Wix account and open the Wix Editor for the site you want to modify.
2.  **Edit Header or Footer:**
    - **For Header Navigation:** Double-click the header section to open the header editor. Select the site menu element.
    - **For Footer:** Scroll down and double-click the footer section to edit it.
3.  **Add a Link:**
    - **Header Menu:** Click "Manage Menu" or similar option. Select "Add Menu Item" > "Link". Choose "Web Address".
    - **Footer:** Select an existing text element or add a new one ("Add" > "Text"). Highlight the text you want to link (e.g., "Feedback", "Roadmap", "Updates"). Click the link icon in the text editor toolbar. Choose "Web Address".
4.  **Enter UserJot URL:** Paste the appropriate UserJot URL (for your feedback board, roadmap, or changelog) into the "Web Address" or URL field.
5.  **Configure Link Settings:** Choose whether the link should open in a new window or the current window. For external links like UserJot, opening in a new window is often preferred.
6.  **Set Link Text (if needed):** If adding a new menu item or text element, type clear link text like "Share Feedback", "View Roadmap", or "See Updates".
7.  **Save and Publish:** Save your changes in the Wix Editor and publish your site to make the links live.

Repeat these steps to add links for each UserJot feature (Feedback, Roadmap, Updates) you want to include on your Wix site.

## Matching UserJot to Your Site Design

For a consistent look between your Wix site and UserJot pages, customize UserJot's appearance:

- **Branding:** Adjust the project name, logo, favicon, and primary color in UserJot's settings to match your Wix site's branding. See the [custom branding guide](https://userjot.com/support/customize-branding).
- **Custom Domain:** Using a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`) makes the integration appear more native to your Wix site.

## Conclusion

Adding UserJot links to your Wix website is a straightforward way to collect feedback, share your roadmap, and announce updates. Start collecting valuable user input on your Wix site today.

# How to Add User Feedback, Roadmap & Changelog to Your WordPress Site with UserJot

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-wordpress
Updated: 2025-04-04

> In WordPress, Custom Links under Appearance → Menus or a footer widget connect a feedback board, public roadmap, and changelog. No plugin, free plan.

Do you need a way to collect user feedback, display a product roadmap, or publish updates on your WordPress website? UserJot offers a straightforward method to integrate these features by adding simple links to your UserJot boards directly from your WordPress site. This guide shows you how.

## Why Connect UserJot to Your WordPress Site?

Integrating UserJot with your WordPress website provides a dedicated space for interacting with your users about your product's direction. You can:

- **Gather user suggestions:** Create a [Feedback Board](https://userjot.com/support/getting-started) where users can submit ideas and vote on existing ones.
- **Display your product roadmap:** Share your development plans using a public [Roadmap](https://userjot.com/support/plan-work) that updates automatically based on feedback status.
- **Announce product updates:** Keep users informed about new features and changes with a clear [Changelog/Updates](https://userjot.com/support/publish-updates) feed.

Adding these features helps build community, increases transparency, and provides valuable insights for your product development directly from your WordPress audience.

## Setting Up Your UserJot Project

Before linking UserJot to WordPress, you need to set up your UserJot project:

1.  **Create your UserJot Account:** Sign up at [UserJot](https://app.userjot.com). A default project with boards will be created for you.
2.  **Find Your Board Links:** Your public UserJot boards are accessible via links. The main link looks like `https://yourproject.userjot.com/`. Specific links for the roadmap and updates are `https://yourproject.userjot.com/roadmap` and `https://yourproject.userjot.com/updates`.
3.  **Consider a Custom Domain (Optional):** For a more branded experience, you can set up a [custom domain](https://userjot.com/support/custom-domain) like `feedback.yourdomain.com`. The links would then be `https://feedback.yourdomain.com/`, `https://feedback.yourdomain.com/roadmap`, and `https://feedback.yourdomain.com/updates`.
4.  **Get Started:** Follow the [getting started guide](https://userjot.com/support/getting-started) for initial setup details.

## Adding UserJot Links to Your WordPress Site

The most common way to integrate UserJot is by adding text links to your WordPress site's navigation menu or footer area.

### Adding Links to Your WordPress Navigation Menu

1.  **Log in** to your WordPress Dashboard.
2.  Navigate to **Appearance > Menus**.
3.  Select the menu you want to edit (often your main navigation).
4.  In the "Add menu items" panel on the left, expand the **Custom Links** section.
5.  In the **URL** field, paste the link to your UserJot board (e.g., `https://yourproject.userjot.com/` or `https://feedback.yourdomain.com/`).
6.  In the **Link Text** field, enter the text you want displayed in the menu (e.g., "Feedback", "Suggest Features", "Roadmap", "Updates").
7.  Click **Add to Menu**.
8.  Drag the new menu item to your desired position in the menu structure.
9.  Repeat steps 4-8 for other UserJot links (Roadmap, Updates).
10. Click **Save Menu**.

### Adding Links to Your WordPress Footer (Widget Area or Site Editor)

The method depends on your WordPress theme (Classic Theme with Widgets or Block Theme with Site Editor).

**For Classic Themes (Using Widgets):**

1.  Log in to your WordPress Dashboard.
2.  Navigate to **Appearance > Widgets**.
3.  Locate the footer widget area (the name varies by theme, e.g., "Footer Column 1", "Footer Bar").
4.  Add a **Text** or **Custom HTML** widget to the desired footer area.
5.  Inside the widget, add your links using basic HTML. See [examples of footer links](https://userjot.com/support/share-your-board). For instance:
    ```html
    <a href="https://yourproject.userjot.com/">Feedback</a><br />
    <a href="https://yourproject.userjot.com/roadmap">Roadmap</a><br />
    <a href="https://yourproject.userjot.com/updates">Updates</a>
    ```
    _(Replace the URLs with your actual UserJot links)_
6.  Click **Save** or **Update**.

**For Block Themes (Using Site Editor):**

1.  Log in to your WordPress Dashboard.
2.  Navigate to **Appearance > Editor**.
3.  Select **Patterns** and find your Footer template part (or navigate directly to the footer area in the site preview).
4.  Click to edit the footer area.
5.  Add a **Paragraph** block or **Navigation** block where you want the links.
6.  Type the link text (e.g., "Feedback").
7.  Select the text and click the link icon in the block toolbar.
8.  Paste your UserJot board URL (e.g., `https://yourproject.userjot.com/`). Press Enter or click the apply button.
9.  Repeat steps 6-8 for other links (Roadmap, Updates).
10. Click **Save**.

## Matching UserJot to Your Site Design

To create a consistent look between your WordPress site and your UserJot boards:

- **Customize Branding:** Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the project name, upload your logo/favicon, and set a primary color that matches your WordPress theme.
- **Use a Custom Domain:** Setting up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`) reinforces your brand identity when users click the links from your WordPress site.

## Conclusion

Adding UserJot links to your WordPress navigation or footer is an effective way to integrate user feedback, roadmap, and changelog features without complex setup. Start collecting valuable user input on your WordPress site today.

# How to Add User Feedback, Roadmap & Changelog Features to Your Zyro Website

Source: https://userjot.com/use-cases/add-user-feedback-roadmap-changelog-to-zyro
Updated: 2025-04-04

> In Zyro, linked footer text or a navigation item set to a web address connects a feedback board, public roadmap, and changelog. No code, free plan.

Want to collect user ideas, share your product plans, or announce updates directly from your Zyro website? This guide explains how to connect UserJot to your Zyro site easily by adding simple links.

## Why Connect UserJot to Your Zyro Site?

Integrating UserJot with your Zyro site lets you gather valuable user suggestions, display your product roadmap publicly, and publish updates about new features. It creates dedicated spaces for users to interact with your product development process. You can learn more about UserJot's capabilities:

- [Get started with UserJot](https://userjot.com/support/getting-started)
- [Plan your roadmap](https://userjot.com/support/plan-work)
- [Publish updates](https://userjot.com/support/publish-updates)

## Setting Up Your UserJot Project

Before adding links to Zyro, you need a UserJot project set up.

1.  **Create a UserJot Account:** If you haven't already, sign up and [create your first UserJot project](https://userjot.com/support/getting-started).
2.  **Identify Your UserJot URLs:** UserJot hosts your feedback board, roadmap, and changelog pages. Find the URLs for these pages in your UserJot dashboard. They will look like `https://yourproject.userjot.com/` or, if you've configured one, a [custom domain](https://userjot.com/support/custom-domain) like `https://feedback.yourdomain.com/`. Specific pages use paths like `/roadmap` and `/updates`. You can see examples of how to structure these links [here](https://userjot.com/support/share-your-board).

## Adding UserJot Links to Your Zyro Site

The most direct way to integrate UserJot with Zyro is by adding links to your site's navigation menu or footer.

### Adding Links to the Zyro Footer

1.  **Log in to Zyro:** Access your Zyro account and open the editor for the website you want to modify.
2.  **Edit Footer:** Scroll down to the footer section of your page template. Click on the footer area to enable editing.
3.  **Add Text Element:** If needed, add a new text element to the footer where you want the links to appear.
4.  **Type Link Text:** Enter the text you want users to click on. Examples: "Share Feedback", "Product Roadmap", "Latest Updates".
5.  **Create the Link:** Select the text you just typed. Click the **link icon** (usually looks like a chain) in the text editing toolbar that appears.
6.  **Enter URL:** In the link settings popup, select the option for linking to a **Web address** or **External URL**. Paste the corresponding UserJot URL (e.g., `https://yourproject.userjot.com/` for feedback, `https://yourproject.userjot.com/roadmap` for the roadmap, `https://yourproject.userjot.com/updates` for the changelog).
7.  **Apply Changes:** Save the link settings.
8.  **Repeat:** Repeat steps 4-7 for each UserJot link (Feedback, Roadmap, Updates).
9.  **Publish:** Remember to publish your Zyro site for the changes to go live.

### Adding Links to the Zyro Navigation Menu

1.  **Log in to Zyro:** Access your Zyro account and open the website editor.
2.  **Open Menu Settings:** Find the 'Website Menu' or 'Navigation' settings in the Zyro editor interface (often in the left sidebar).
3.  **Add Link Item:** Choose the option to 'Add item' or 'Add link'.
4.  **Select Link Type:** Choose 'External Link' or 'Web address' as the link type.
5.  **Configure Link:**
    - Enter the **Link Text** (e.g., "Feedback", "Roadmap").
    - Paste the corresponding **UserJot URL**.
6.  **Save and Arrange:** Save the new menu item. You can usually drag and drop menu items to reorder them.
7.  **Repeat:** Repeat steps 3-6 for other UserJot pages you want in the navigation.
8.  **Publish:** Publish your Zyro site to see the updated navigation.

## Matching UserJot to Your Site Design

For a more integrated appearance:

- Use UserJot's [branding options](https://userjot.com/support/customize-branding) to change the project name, upload your logo and favicon, and set a primary color that matches your Zyro site's design.
- Consider setting up a [custom domain](https://userjot.com/support/custom-domain) (e.g., `feedback.yourdomain.com`) so the URLs feel like a natural part of your website.

## Conclusion

Adding links to UserJot from your Zyro website is a straightforward way to start collecting user feedback, sharing your plans, and announcing updates. You can now easily connect with your users directly through your Zyro site using UserJot.