how we can accomplish showing specific visualizations based on configurations for the client. e.g. if we have a client that is using campaign feature, we show campaign related visualizations based on configurations we would store in the data. So if client does not have feature turned on, we do not show those visualizations/reports. Please let me know if you have any questions. Thank you!

Showing Visualizations Based on Client Feature Configuration This is a great use case, and there are a few approaches in GoodData you can consider, though native conditional visibility of dashboard widgets based on data logic is not currently supported as a built-in feature. [Community Slack] Here are the practical options available: Option 1: Separate Dashboards per Client Feature Set (Recommended for Security) Use Workspace Data Filters (WDF) or User Data Filters (UDF) to control what data is visible per client/workspace. You can maintain separate dashboards tailored to each feature set, and control access via dashboard permissions so clients only see dashboards relevant to them. [Workspace Data Filters] Option 2: Tag-Based Catalog Filtering in Embedded Mode If you're embedding GoodData via iframes, you can use URL parameters to show/hide catalog items (metrics, attributes, facts) based on tags: •

includeObjectsWithTags=[campaign]

— only show campaign-related items •

excludeObjectsWithTags=[campaign]

— hide campaign-related items Example:

<host_url>/dashboards/embedded/#/workspace/<workspace_id>/dashboard/<dashboard_id>?excludeObjectsWithTags=[campaign]

> ⚠️ Note: This only affects the data catalog (what users can add to visualizations) — it does not hide existing widgets already placed on a dashboard. Also, there is a known bug where

excludeObjectsWithTags

may also hide untagged objects. [Community Slack] Option 3: Control Visibility in Your React App (Programmatic Approach) If you're using the GoodData React SDK, you can implement the conditional logic entirely in your application layer: 1. Store the client's feature configuration in your own data/config store. 2. Conditionally render

InsightView

components based on whether the client has a feature enabled. 3. Use Visualization Definition Placeholders to dynamically swap measures/attributes at runtime based on user context. [Visualization Placeholders] This gives you full control — if a client doesn't have the campaign feature, simply don't render the campaign-related

InsightView

components. Option 4: Dashboard Permissions You can create separate dashboards for campaign features and restrict access using dashboard permissions, so only clients with the campaign feature enabled can see those dashboards. [Community Slack] Summary The most flexible and recommended approach for your use case (feature-flag-driven visibility) is likely React conditional rendering combined with your own configuration store, as GoodData does not natively support hiding individual widgets based on data logic at this time. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups. 👀 Our Support team monitors all messages and will jump in if needed., with interactive elements

Hi Krishti, happy to help here and thanks for the detail. Just to make sure we point you in the right direction — when you say "campaign feature," is that a flag or configuration stored in the same data source GoodData connects to (e.g. a column or table indicating which clients have which features enabled), or is it managed in your application layer separately? The answer changes the approach: if it's in the data, there are options on the GoodData side. If it's in your app, the cleanest path is conditional rendering in the React SDK — you simply don't mount the relevant

InsightView

components for clients without that feature.

We have a dashboard containing 10 visualizations that is embedded into approximately 300 seller-specific sites using the React SDK. The dashboard is filtered automatically based on the logged-in seller. Seller is an attribute in the data model. We maintain a configuration table similar to the following: SellerCampaign_FlagMarket_Flag...Seller AYN...Seller BNY...Seller CYY... The requirement is to conditionally display dashboard visualizations based on feature flags assigned to each seller. Examples: • If

Campaign_Flag = N

, all campaign-related visualizations should be hidden. • If

Market_Flag = N

, all market-related visualizations should be hidden. • Multiple flags may be enabled or disabled simultaneously, creating many possible combinations. Our goal is to support these dynamic visibility rules without maintaining multiple copies of the same dashboard. We are looking for a scalable solution where visualization visibility can be controlled at runtime based on seller-specific feature flags. @kapa.ai

GoodData does not currently support native, data-driven conditional visibility of individual dashboard widgets (insights) at runtime, so this cannot be solved purely by configuration on the dashboard itself. [Slack – conditional visibility] Given your setup (React SDK, one dashboard, many sellers, feature flags), here are the realistic options and what they can / cannot do: 1. React SDK: Control Visibility in Your App (Recommended) Since you already embed via React SDK, the most scalable and flexible approach is to move the visibility logic into your React app: 1. Fetch seller feature flags (e.g., from your config table) when the seller logs in. 2. Do not render campaign/market-related content when the corresponding flag is

N

. There are two main patterns: 1a) Replace the dashboard with multiple InsightViews Instead of embedding the whole dashboard as a black box, embed its insights individually: • Create the 10 insights in GoodData (the same ones used on the dashboard). • In React, render each

InsightView

only if the seller has the feature:

{sellerFlags.Campaign_Flag === "Y" && (
    <InsightView insight="campaign_insight_id" />
)}

{sellerFlags.Market_Flag === "Y" && (
    <InsightView insight="market_insight_id" />
)}

This gives you per-visualization control and still reuses the same GoodData insights. This is exactly the kind of “feature-flag-driven visibility” that the community answer recommends solving in the app layer. [Slack – feature flags; React SDK embedding] You can further use Visualization Definition Placeholders if you want to dynamically swap measures/attributes inside a chart based on flags, instead of hiding it entirely. [Visualization placeholders] 1b) Use the Dashboard component + Dashboard Plugins (advanced) The knowledge sources mention that dashboard plugins might be able to implement dynamic hiding, but they also state this is not documented and would need custom development and scoping. [Slack – tags & plugins; Dashboard Plugin API] From the docs: • You can customize how visualization widgets are rendered via

insightWidgets().withCustomProvider()

or

withTag()

. [Dashboard Plugin API] • In your custom provider, you could decide not to render certain widgets (or render an empty placeholder) based on tags and seller flags. However: • The docs do not provide a complete example of “hide widget based on external flags”. • Support explicitly notes they are not sure what exactly plugins can/cannot do and suggest involving Professional Services for such solutions. [Slack – tags & plugins] So this is possible but advanced and not fully covered by the available documentation. 2. What will not solve your requirement Based on the docs, these options cannot hide existing widgets: • Tag-based iframe parameters (

includeObjectsWithTags

,

excludeObjectsWithTags

) only filter the data catalog in edit mode; they do not hide widgets already on the dashboard. [Tag-based filtering; Slack – catalog only] • Workspace Data Filters / User Data Filters restrict data, not widget visibility. A campaign chart would still be visible; it might just show no data. [Secure filtering approaches] 3. Recommended architecture for your case Given: • ~300 sellers • One shared dashboard design • Many combinations of feature flags • Need to avoid cloning dashboards The most practical and documented path from the available sources is: 1. Keep a single set of insights in GoodData (reused across sellers). 2. Embed via React SDK using

InsightView

(or chart components) instead of a monolithic

Dashboard

. 3. Drive visibility from your feature-flag table in your app: ◦ Map each insight to one or more flags (e.g.,

campaign

,

market

). ◦ At render time, check the seller’s flags and conditionally render each insight. This gives you: • No dashboard duplication. • Full runtime control per seller. • A solution fully aligned with what GoodData staff and community recommend for feature-flag-driven visibility. [Slack – feature flags; React SDK] If you specifically must keep the single dashboard as-is (for authors) but still want runtime hiding inside that dashboard, the only path hinted in the docs is a custom dashboard plugin, which would require custom coding and likely engagement with GoodData Professional Services. The knowledge sources do not provide a ready-made implementation for that. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups. 👀 Our Support team monitors all messages and will jump in if needed.

@kapa.ai We want to maintain one dashboard which have multiple visualization but based on flag certain visualization should visible or hidden for seller. We maintain a configuration table similar to the following: Seller Campaign_Flag Market_Flag ... Seller A Y N ... Seller B N Y ... Seller C Y Y ...

GoodData’s current capabilities do not support native, data‑driven “show/hide this widget on a dashboard based on flags” as a built‑in feature. This is explicitly called out in community answers: conditional visibility of dashboard widgets based on data logic is not available and is not on the near‑term roadmap. [Conditional visibility feedback; Feature‑flag use case] Given your requirement: • One dashboard with multiple visualizations • Per‑seller flags like

Campaign_Flag

,

Market_Flag

• Need to hide/show specific visualizations per seller at runtime the knowledge sources point to these realistic options: 1. Recommended: Control visibility in your React app (per‑insight embedding) Because you are using the React SDK, the recommended and most flexible solution is to move the visibility logic into your application: 1. Keep your configuration table (Seller → flags) in your own DB/service. 2. For each seller, load their flags (

Campaign_Flag

,

Market_Flag

, …). 3. Instead of embedding the whole dashboard as a single

<Dashboard />

black box, embed the individual insights (the same ones that are on the dashboard) using

InsightView

or chart components. 4. Conditionally render each insight based on the flags:

{sellerFlags.Campaign_Flag === "Y" && (
    <InsightView insight="campaign_insight_id" />
)}

{sellerFlags.Market_Flag === "Y" && (
    <InsightView insight="market_insight_id" />
)}

This pattern is exactly what GoodData staff recommend for “feature‑flag‑driven visibility”: implement the conditional logic in your React layer and simply do not render the

InsightView

components for features that are off. [Feature‑flag use case] If you need to dynamically change what a visualization shows (rather than hide it), you can also use Visualization Definition Placeholders to swap measures/attributes at runtime based on flags. [Visualization placeholders] 2. Why a single dashboard cannot do this by itself From the available docs: • There is no built‑in conditional visibility for dashboard widgets based on data or flags. [Conditional visibility feedback] • Tag‑based URL parameters (

includeObjectsWithTags

,

excludeObjectsWithTags

) only filter the data catalog in edit mode; they do not hide existing widgets on a dashboard. [Tag‑based filtering; Slack – catalog only] • Workspace Data Filters / User Data Filters restrict data visibility, not whether a widget is shown; a chart may just appear empty. [Secure filtering approaches] There is mention that custom dashboard plugins can manipulate widget rendering and even hide layout elements using low‑level DOM tricks, but this is advanced, not fully documented for your exact use case, and support explicitly notes uncertainty about the full capabilities. [Dashboard Plugin API; Slack – plugins & capabilities; Insight groups plugin] 3. Practical conclusion for your scenario With the information available: • You cannot have one GoodData dashboard automatically hide/show its widgets per seller based only on your flag table. • The supported, scalable way is: ◦ Keep a single set of insights in GoodData. ◦ Use the React SDK to embed those insights individually. ◦ Use your Seller → Flag configuration to decide which insights to render for each seller at runtime. If you must keep the single dashboard UI and still want in‑dashboard hiding, the only hinted path is a custom dashboard plugin, likely requiring custom development and possibly GoodData Professional Services; the knowledge sources do not provide a ready‑made solution for that. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups. 👀 Our Support team monitors all messages and will jump in if needed.

@kapa.ai It seems I need human intervention. We do not want to do individual insight embed. For better scalability, we do dashboard embed with udf using react sdk only. Now we want to add this feature that based on seller attribute ( we have 300 sellers) certain visualization hide/show.

You’re right that this is a case where product limitations matter, so I’ll be very direct and keep it tied to what’s in the sources. 1. What GoodData can / cannot do today From the available docs and Slack answers: • There is no native way to conditionally hide/show individual dashboard widgets (insights) based on data or attributes (like seller or flags). [Conditional visibility feedback; Feature‑flag use case] • Tag-based URL parameters (

includeObjectsWithTags

,

excludeObjectsWithTags

) only affect the data catalog in edit mode; they do not hide existing widgets on a dashboard. [Tag-based filtering; Slack – catalog only] • UDF/WDF restrict data visibility, not widget visibility; a chart may just be empty. [Secure filtering approaches] So with dashboard embed + UDF via React SDK only, there is no documented, supported mechanism to say “for seller X, hide widgets A,B,C; for seller Y, hide D,E,F” while keeping a single dashboard definition. 2. Why the usual workaround (per‑insight embed) was suggested The community answer for a very similar “feature-flag per client” scenario explicitly recommends moving the visibility logic to the React layer and conditionally rendering

InsightView

components, because GoodData does not support widget-level conditional visibility on dashboards. [Feature‑flag use case] You’ve ruled this out, but from the product side that is the documented scalable pattern. 3. Dashboard plugins: only partial / uncertain fit There are hints that custom dashboard plugins can manipulate how widgets are rendered: • The Dashboard Plugin API lets you customize rendering of visualization widgets via

insightWidgets().withCustomProvider()

or

withTag()

. [Dashboard Plugin API] • An example “insight groups” plugin even notes that the current API does not allow clean real-time layout modifications, and it resorts to low-level DOM tricks to hide layout widgets. [Insight groups plugin] • Support explicitly says they are not 100% sure what plugins can/cannot do and suggests involving Professional Services for such custom behavior. [Slack – tags & plugins] So, technically, a plugin might be able to: • Tag campaign/market insights. • At runtime, decide (based on seller flags you pass somehow) to render nothing or hide those tagged widgets. But: the knowledge sources do not provide a concrete, supported recipe for “per-seller hide/show via plugin”, and even the example plugin calls out API limitations and DOM hacks. [Insight groups plugin] 4. What this means for your requirement Given what’s documented: • With one dashboard + UDF + React SDK dashboard embed only, there is no supported way in the docs to implement per‑seller widget hide/show based on flags. • The supported patterns are: ◦ Control visibility in your app (per‑insight embedding / conditional rendering). [Feature‑flag use case] ◦ Use separate dashboards and control access via dashboard permissions (but that explodes with many combinations). [Dashboard permissions] • A custom dashboard plugin is the only hinted path to keep a single dashboard and still hide widgets, but: ◦ It’s not documented for your exact use case. ◦ Even the example plugin notes limitations. ◦ Support suggests this is something to discuss with GoodData Professional Services. [Slack – tags & plugins] 5. Concrete next steps Within what’s in the sources, your realistic options are: 1. Reconsider per‑insight embedding for seller‑specific sites (even if you keep the dashboard for internal use), and drive visibility from your Seller → Flag table in React. 2. Engage GoodData support / Professional Services to explore a custom dashboard plugin that: ◦ Uses tags on insights to identify “campaign”, “market”, etc. ◦ Reads seller flags from some context (e.g., plugin parameters or local storage). ◦ Hides or replaces those widgets at runtime. The knowledge sources do not contain enough information to describe a safe, fully supported implementation of option 2; they only confirm that plugins can customize rendering and that hiding widgets has been done with low-level DOM workarounds. [Dashboard Plugin API; Insight groups plugin] If you share whether involving a plugin / PS is acceptable, I can outline, at a high level, how you’d structure tags and flags around that, within the limits of what’s documented. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups. 👀 Our Support team monitors all messages and will jump in if needed.