My Profile
Sign Out
Tickets
Knowledge Base
Login
Articles in this section
  2. Embedding

How to Enable Personal Dashboard Creation in an Bold BI Embedded Application

Published:

Overview

This article explains how to enable end users to create and manage their own personal dashboards within an embedded Bold BI application. By assigning the required permissions and embedding the Dashboard Designer, users can create dashboards, publish them to their own workspace, and manage them independently without affecting dashboards owned by other users.
This approach is recommended for self-service analytics scenarios where each application user should be able to build and maintain their own dashboards while maintaining proper ownership, security, and access control.

Prerequisites

Before enabling personal dashboard creation in an embedded application, ensure that:

  • The user exists in the Bold BI site.
  • The user has permissions to create dashboards and data sources.
  • User-based authorization is implemented in the embedded application.
  • The Dashboard Designer is enabled in the embedded environment.
  • Embed tokens are generated for authenticated users from the server-side application.

Step 1: Add the User to Bold BI

If the application user does not already exist in the Bold BI site, create the user programmatically using the Bold BI User API.

Self-Hosted Server API

https://{yourdomain}/bi/api/site/{site_identifier}/v5.0/users

Bold BI Cloud API

https://{yourdomain}/bi/api/v5.0/users

For API implementation details, refer to the Add User API documentation.

Step 2: Assign Dashboard Creation Permissions

Grant the required permissions that allow the user to create and manage dashboards and data sources.
The recommended permissions are:

  • Create Dashboard
  • Create Data Source
  • Read Data Source
  • Write Data Source

Self-Hosted Server API

https://{yourdomain}/bi/api/site/{site_identifier}/v5.0/permissions/users

Bold BI Cloud API

https://{yourdomain}/bi/api/v5.0/permissions/users

For API implementation details, refer to the Add User Permission API documentation.

Step 3: Generate an Embed Token

To securely embed the Dashboard Designer, generate an embed token from your backend application.
The embed token:

  • Authenticates the user.
  • Applies user-specific permissions.
  • Determines the user’s access level within the embedded experience.

Important: Always generate embed tokens from the server-side application. Never expose the Embed Secret Key in client-side code.

ASP.NET Token Generation Example

[HttpPost]
[Route("TokenGeneration")]
public string TokenGeneration()
{
    var embedDetails = new
    {
        serverurl = "<Bold BI Server URL>",
        siteidentifier = "<Site Identifier>",
        email = "<User Email>",
        embedsecret = "<Embed Secret Key>",
        dashboard = new
        {
            // Required only for Bold BI version 14.1.11
            id = "<Dashboard Id>"
        }
    };
    var client = new HttpClient();
    var requestUrl =
        $"{embedDetails.serverurl}/api/{embedDetails.siteidentifier}/embed/authorize";
    var jsonPayload =
        JsonConvert.SerializeObject(embedDetails);
    var httpContent =
        new StringContent(
            jsonPayload,
            Encoding.UTF8,
            "application/json");
    var result =
        client.PostAsync(requestUrl, httpContent).Result;
    var resultContent =
        result.Content.ReadAsStringAsync().Result;
    return JsonConvert
        .DeserializeObject<dynamic>(resultContent)
        .Data.access_token;
}

Note: The dashboard.id property is required only when generating embed tokens in Bold BI version 14.1.11. Verify the requirement for your deployed version before implementation.

Step 4: Embed the Dashboard Designer

After generating the embed token, load the Dashboard Designer inside your application using Design mode.

Client-Side Implementation

<body onload="embedSample();">
    <div id="embed_container"></div>
    <script>
        function embedSample() {
            var boldbiEmbedInstance = BoldBI.create({
                serverUrl: "<Bold BI Server URL>",
                mode: BoldBI.Mode.Design,
                embedContainerId: "embed_container",
                embedToken: "<Embed Token>"
            });
            boldbiEmbedInstance.loadDesigner();
        }
    </script>
</body>

How It Works

  1. The application authenticates the user.
  2. The backend generates an embed token.
  3. The embed token is sent to the client application.
  4. The Dashboard Designer is loaded in Design mode.
  5. The user can create and publish dashboards within the embedded environment.

Step 5: Publish Dashboards to User-Specific Categories

Once the Dashboard Designer is loaded, users with the appropriate permissions can create and publish dashboards directly from the embedded application.
To maintain dashboard ownership and ensure tenant isolation, publish newly created dashboards to a dedicated category for each user instead of using a shared category.

Recommended Approach

For better ownership and security, create a dedicated Bold BI user and a dedicated category for each application user. When users publish dashboards from the embedded Dashboard Designer, ensure the dashboards are saved to their respective categories. This approach helps maintain content isolation, simplifies access management, and prevents users from unintentionally modifying or accessing dashboards owned by other users.

Benefits

Publishing dashboards to user-specific categories ensures that:

  • Each user owns the dashboards they create.
  • Dashboards remain isolated from other users.
  • Other users cannot view or modify dashboards unless explicit permissions are granted.
  • Users can independently manage their dashboard content.
  • Administrative management becomes simpler and more secure.

Permissions for Personal Categories

For each user-specific category:

Permission Recommendation
Read Allow
Create Allow
Edit Allow
Delete Optional
Share Based on business requirements

For shared categories:

Permission Recommendation
Read Allow if required
Create Restrict
Edit Restrict
Delete Restrict

Important: If users are allowed to publish dashboards to shared categories, dashboards may become visible to other users depending on the category permission settings. To maintain isolation, publish personal dashboards only to user-specific categories.

Best Practices

When enabling self-service dashboard creation in embedded applications:

  • Create a unique Bold BI user for every application user instead of using a shared account.
  • Create a dedicated category for each user.
  • Publish all dashboards created by a user to that user’s category.
  • Restrict category permissions so users can access only their own categories.
  • Use meaningful category names such as email addresses or unique user identifiers.
  • Prevent publishing to administrative or shared categories unless explicitly required.
  • Grant only the minimum permissions required for dashboard management.
  • Regularly review user permissions and category ownership.
  • Use server-side token generation to protect the Embed Secret Key.

Additional Considerations

User-Based Authorization

User-based authorization is essential for personal dashboard ownership because it:

  • Associates dashboards with individual users.
  • Enables category-level security.
  • Enforces permission-based access control.
  • Supports personalized self-service analytics experiences.

API Version Compatibility

The examples in this article use API version v5.0.

Note: API endpoints and request payloads may vary depending on your Bold BI version. Refer to the latest API documentation to verify compatibility before implementation.

Conclusion

By embedding the Dashboard Designer and configuring appropriate user permissions, you can enable end users to create and manage personal dashboards directly within an embedded Bold BI application. Assigning a dedicated Bold BI user and category to each application user helps maintain dashboard ownership, enforce security boundaries, and ensure content isolation.

Following this approach provides a scalable and secure self-service analytics experience while allowing users to independently create, edit, and manage their dashboards without affecting shared content.

Additional References
Attachments
Was this article useful?
Like
Dislike
Help us improve this page
Please provide feedback or comments
DE
Written by Dhanasekaran Ekambaram
Updated:
Comments (0)
Access denied
Access denied