diff --git a/src/api/settings.js b/src/api/settings.js
index 6ed0672cd..ab26947b5 100644
--- a/src/api/settings.js
+++ b/src/api/settings.js
@@ -1,9 +1,34 @@
 export const DEFAULT_SETTINGS = {
     displayNameProperty: 'displayName',
+    keyDashboardContextMenuItemOpenInRelevantApp: true,
+    keyDashboardContextMenuItemShowInterpretationsAndDetails: true,
+    keyDashboardContextMenuItemSwitchViewType: true,
+    keyDashboardContextMenuItemViewFullscreen: true,
     keyGatherAnalyticalObjectStatisticsInDashboardViews: false,
 }
 
-const SYSTEM_SETTINGS = ['keyGatherAnalyticalObjectStatisticsInDashboardViews']
+const SYSTEM_SETTINGS = [
+    'keyDashboardContextMenuItemOpenInRelevantApp',
+    'keyDashboardContextMenuItemShowInterpretationsAndDetails',
+    'keyDashboardContextMenuItemSwitchViewType',
+    'keyDashboardContextMenuItemViewFullscreen',
+    'keyGatherAnalyticalObjectStatisticsInDashboardViews',
+]
+
+const SYSTEM_SETTINGS_REMAPPINGS = {
+    keyDashboardContextMenuItemOpenInRelevantApp: 'openInRelevantApp',
+    keyDashboardContextMenuItemShowInterpretationsAndDetails:
+        'showInterpretationsAndDetails',
+    keyDashboardContextMenuItemSwitchViewType: 'switchViewType',
+    keyDashboardContextMenuItemViewFullscreen: 'fullscreenAllowedInSettings',
+}
+
+export const renameSystemSettings = settings => {
+    return Object.keys(settings).reduce((mapped, key) => {
+        mapped[SYSTEM_SETTINGS_REMAPPINGS[key] || key] = settings[key]
+        return mapped
+    }, {})
+}
 
 const query = {
     resource: 'systemSettings',
diff --git a/src/components/Item/VisualizationItem/ItemHeaderButtons.js b/src/components/Item/VisualizationItem/ItemHeaderButtons.js
index cb5f8576d..db58dd272 100644
--- a/src/components/Item/VisualizationItem/ItemHeaderButtons.js
+++ b/src/components/Item/VisualizationItem/ItemHeaderButtons.js
@@ -31,16 +31,24 @@ import {
     hasMapView,
     getAppName,
 } from '../../../modules/itemTypes'
+import { useSystemSettings } from '../../SystemSettingsProvider'
 
 const iconFill = { fill: colors.grey600 }
 
 const ItemHeaderButtons = props => {
-    const [menuIsOpen, setMenuIsOpen] = useState(null)
+    const [menuIsOpen, setMenuIsOpen] = useState(props.isOpen)
 
     const { baseUrl } = useConfig()
 
     const { item, visualization, onSelectActiveType, activeType } = props
 
+    const {
+        openInRelevantApp,
+        showInterpretationsAndDetails,
+        switchViewType,
+        fullscreenAllowedInSettings,
+    } = useSystemSettings().settings
+
     const isTrackerType = isTrackerDomainType(item.type)
 
     const onViewTable = () => {
@@ -77,6 +85,7 @@ const ItemHeaderButtons = props => {
 
     const type = visualization.type || item.type
     const canViewAs =
+        switchViewType &&
         !isSingleValue(type) &&
         !isYearOverYear(type) &&
         type !== VIS_TYPE_GAUGE &&
@@ -117,6 +126,17 @@ const ItemHeaderButtons = props => {
 
     const buttonRef = createRef()
 
+    const fullscreenAllowed =
+        props.fullscreenSupported && fullscreenAllowedInSettings
+
+    if (
+        !openInRelevantApp &&
+        !showInterpretationsAndDetails &&
+        !switchViewType &&
+        !fullscreenAllowed
+    ) {
+        return null
+    }
     return props.isFullscreen ? (
         <Button small secondary onClick={props.onToggleFullscreen}>
             <ExitFullscreen />
@@ -144,25 +164,33 @@ const ItemHeaderButtons = props => {
                         {canViewAs && (
                             <>
                                 <ViewAsMenuItems />
-                                <Divider />
+                                {(showInterpretationsAndDetails ||
+                                    openInRelevantApp ||
+                                    fullscreenAllowed) && <Divider />}
                             </>
                         )}
-                        <MenuItem
-                            dense
-                            icon={<LaunchIcon style={{ fill: '#6e7a8a' }} />}
-                            label={i18n.t('Open in {{appName}} app', {
-                                appName: getAppName(item.type),
-                            })}
-                            href={getLink(item, baseUrl)}
-                            target="_blank"
-                        />
-                        <MenuItem
-                            dense
-                            icon={<SpeechBubble />}
-                            label={interpretationMenuLabel}
-                            onClick={handleInterpretationClick}
-                        />
-                        {props.fullscreenSupported && (
+                        {openInRelevantApp && (
+                            <MenuItem
+                                dense
+                                icon={
+                                    <LaunchIcon style={{ fill: '#6e7a8a' }} />
+                                }
+                                label={i18n.t('Open in {{appName}} app', {
+                                    appName: getAppName(item.type),
+                                })}
+                                href={getLink(item, baseUrl)}
+                                target="_blank"
+                            />
+                        )}
+                        {showInterpretationsAndDetails && (
+                            <MenuItem
+                                dense
+                                icon={<SpeechBubble />}
+                                label={interpretationMenuLabel}
+                                onClick={handleInterpretationClick}
+                            />
+                        )}
+                        {fullscreenAllowed && (
                             <MenuItem
                                 dense
                                 icon={<Fullscreen />}
@@ -182,6 +210,7 @@ ItemHeaderButtons.propTypes = {
     activeType: PropTypes.string,
     fullscreenSupported: PropTypes.bool,
     isFullscreen: PropTypes.bool,
+    isOpen: PropTypes.bool,
     item: PropTypes.object,
     visualization: PropTypes.object,
     onSelectActiveType: PropTypes.func,
diff --git a/src/components/Item/VisualizationItem/__tests__/ItemHeaderButtons.spec.js b/src/components/Item/VisualizationItem/__tests__/ItemHeaderButtons.spec.js
index 5b3d3b359..d7f464a09 100644
--- a/src/components/Item/VisualizationItem/__tests__/ItemHeaderButtons.spec.js
+++ b/src/components/Item/VisualizationItem/__tests__/ItemHeaderButtons.spec.js
@@ -2,13 +2,37 @@ import React from 'react'
 import { shallow } from 'enzyme'
 import toJson from 'enzyme-to-json'
 import ItemHeaderButtons from '../ItemHeaderButtons'
+import { useSystemSettings } from '../../../SystemSettingsProvider'
 
 jest.mock('../Visualization/plugin', () => ({
     getLink: () => 'http://rainbowdash',
     pluginIsAvailable: () => true,
 }))
 
+jest.mock('@dhis2/analytics', () => ({
+    isSingleValue: () => {
+        return false
+    },
+    isYearOverYear: () => {
+        return false
+    },
+}))
+
+jest.mock('../../../SystemSettingsProvider', () => ({
+    useSystemSettings: jest.fn(),
+}))
+
+const mockSystemSettingsDefault = {
+    settings: {
+        openInRelevantApp: true,
+        showInterpretationsAndDetails: true,
+        switchViewType: true,
+        fullscreenAllowedInSettings: true,
+    },
+}
+
 it('renders correctly when not fullscreen', () => {
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettingsDefault)
     const buttons = shallow(
         <ItemHeaderButtons
             item={{
@@ -29,6 +53,7 @@ it('renders correctly when not fullscreen', () => {
 })
 
 it('renders correctly when fullscreen', () => {
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettingsDefault)
     const buttons = shallow(
         <ItemHeaderButtons
             item={{
@@ -48,3 +73,213 @@ it('renders correctly when fullscreen', () => {
     )
     expect(toJson(buttons)).toMatchSnapshot()
 })
+
+it('renders Menu Items when open', () => {
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettingsDefault)
+    const container = shallow(
+        <ItemHeaderButtons
+            item={{
+                type: 'CHART',
+                chart: { type: 'NOT_YOY', domainType: 'AGGREGATE' },
+            }}
+            visualization={{
+                type: 'SINGLE_VALUE',
+            }}
+            onSelectActiveType={Function.prototype}
+            activeFooter={false}
+            activeType={'CHART'}
+            d2={{}}
+            onToggleFooter={Function.prototype}
+            isFullscreen={false}
+            fullscreenSupported={true}
+            isOpen={true}
+        />
+    )
+
+    expect(toJson(container)).toMatchSnapshot()
+})
+
+it('does not render ViewAsMenuItems Items if settings do not allow', () => {
+    const mockSystemSettings = { settings: {} }
+    mockSystemSettings.settings = Object.assign(
+        {},
+        mockSystemSettingsDefault.settings,
+        {
+            switchViewType: false,
+        }
+    )
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettings)
+    const container = shallow(
+        <ItemHeaderButtons
+            item={{
+                type: 'CHART',
+                chart: { type: 'NOT_YOY', domainType: 'AGGREGATE' },
+            }}
+            visualization={{
+                type: 'SINGLE_VALUE',
+            }}
+            onSelectActiveType={Function.prototype}
+            activeFooter={false}
+            activeType={'CHART'}
+            d2={{}}
+            onToggleFooter={Function.prototype}
+            isFullscreen={false}
+            fullscreenSupported={true}
+            isOpen={true}
+        />
+    )
+    expect(container.find('ViewAsMenuItems').exists()).toBeFalsy()
+})
+
+it('does not let you open in relevant app if settings do not allow', () => {
+    const mockSystemSettings = { settings: {} }
+    mockSystemSettings.settings = Object.assign(
+        {},
+        mockSystemSettingsDefault.settings,
+        {
+            openInRelevantApp: false,
+        }
+    )
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettings)
+    const container = shallow(
+        <ItemHeaderButtons
+            item={{
+                type: 'CHART',
+                chart: { type: 'NOT_YOY', domainType: 'AGGREGATE' },
+            }}
+            visualization={{
+                type: 'SINGLE_VALUE',
+            }}
+            onSelectActiveType={Function.prototype}
+            activeFooter={false}
+            activeType={'CHART'}
+            d2={{}}
+            onToggleFooter={Function.prototype}
+            isFullscreen={false}
+            fullscreenSupported={true}
+            isOpen={true}
+        />
+    )
+    expect(
+        container
+            .findWhere(
+                n =>
+                    n.name() === 'MenuItem' &&
+                    n.prop('label') === 'Open in Data Visualizer app'
+            )
+            .exists()
+    ).toBeFalsy()
+})
+
+it('does not let you open in fullscreen if settings do not allow', () => {
+    const mockSystemSettings = { settings: {} }
+    mockSystemSettings.settings = Object.assign(
+        {},
+        mockSystemSettingsDefault.settings,
+        {
+            fullscreenAllowedInSettings: false,
+        }
+    )
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettings)
+    const container = shallow(
+        <ItemHeaderButtons
+            item={{
+                type: 'CHART',
+                chart: { type: 'NOT_YOY', domainType: 'AGGREGATE' },
+            }}
+            visualization={{
+                type: 'SINGLE_VALUE',
+            }}
+            onSelectActiveType={Function.prototype}
+            activeFooter={false}
+            activeType={'CHART'}
+            d2={{}}
+            onToggleFooter={Function.prototype}
+            isFullscreen={false}
+            fullscreenSupported={true}
+            isOpen={true}
+        />
+    )
+    expect(
+        container
+            .findWhere(
+                n =>
+                    n.name() === 'MenuItem' &&
+                    n.prop('label') === 'View fullscreen'
+            )
+            .exists()
+    ).toBeFalsy()
+})
+
+it('does not let you open interpretations and details if settings do not allow', () => {
+    const mockSystemSettings = { settings: {} }
+    mockSystemSettings.settings = Object.assign(
+        {},
+        mockSystemSettingsDefault.settings,
+        {
+            showInterpretationsAndDetails: false,
+        }
+    )
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettings)
+    const container = shallow(
+        <ItemHeaderButtons
+            item={{
+                type: 'CHART',
+                chart: { type: 'NOT_YOY', domainType: 'AGGREGATE' },
+            }}
+            visualization={{
+                type: 'SINGLE_VALUE',
+            }}
+            onSelectActiveType={Function.prototype}
+            activeFooter={false}
+            activeType={'CHART'}
+            d2={{}}
+            onToggleFooter={Function.prototype}
+            isFullscreen={false}
+            fullscreenSupported={true}
+            isOpen={true}
+        />
+    )
+    expect(
+        container
+            .findWhere(
+                n =>
+                    n.name() === 'MenuItem' &&
+                    n.prop('label') === 'Show interpretations and details'
+            )
+            .exists()
+    ).toBeFalsy()
+})
+
+it('does not render buttons if all relevant settings are false', () => {
+    const mockSystemSettings = {
+        settings: {
+            openInRelevantApp: false,
+            showInterpretationsAndDetails: false,
+            switchViewType: false,
+            fullscreenAllowedInSettings: false,
+        },
+    }
+
+    useSystemSettings.mockImplementationOnce(() => mockSystemSettings)
+    const buttons = shallow(
+        <ItemHeaderButtons
+            item={{
+                type: 'CHART',
+                chart: { type: 'NOT_YOY', domainType: 'AGGREGATE' },
+            }}
+            visualization={{
+                type: 'SINGLE_VALUE',
+            }}
+            onSelectActiveType={Function.prototype}
+            activeFooter={false}
+            activeType={'CHART'}
+            d2={{}}
+            onToggleFooter={Function.prototype}
+            isFullscreen={false}
+            fullscreenSupported={true}
+            isOpen={true}
+        />
+    )
+    expect(toJson(buttons)).toBeFalsy()
+})
diff --git a/src/components/Item/VisualizationItem/__tests__/__snapshots__/ItemHeaderButtons.spec.js.snap b/src/components/Item/VisualizationItem/__tests__/__snapshots__/ItemHeaderButtons.spec.js.snap
index e8bd42db8..35816b482 100644
--- a/src/components/Item/VisualizationItem/__tests__/__snapshots__/ItemHeaderButtons.spec.js.snap
+++ b/src/components/Item/VisualizationItem/__tests__/__snapshots__/ItemHeaderButtons.spec.js.snap
@@ -1,5 +1,74 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`renders Menu Items when open 1`] = `
+<Fragment>
+  <div>
+    <Button
+      dataTest="dashboarditem-menu-button"
+      onClick={[Function]}
+      secondary={true}
+      small={true}
+      type="button"
+    >
+      <ThreeDots />
+    </Button>
+  </div>
+  <Popover
+    arrow={false}
+    dataTest="dhis2-uicore-popover"
+    elevation="0 0 1px 0 rgba(64,75,90,0.29), 0 3px 8px -2px rgba(64,75,90,0.30)"
+    maxWidth={360}
+    onClickOutside={[Function]}
+    placement="auto-start"
+    reference={
+      Object {
+        "current": null,
+      }
+    }
+  >
+    <Menu
+      dataTest="dhis2-uicore-menulist"
+    >
+      <ViewAsMenuItems />
+      <Divider
+        dataTest="dhis2-uicore-divider"
+        margin="8px 0"
+      />
+      <MenuItem
+        dataTest="dhis2-uicore-menuitem"
+        dense={true}
+        href="http://rainbowdash"
+        icon={
+          <UNDEFINED
+            style={
+              Object {
+                "fill": "#6e7a8a",
+              }
+            }
+          />
+        }
+        label="Open in Data Visualizer app"
+        target="_blank"
+      />
+      <MenuItem
+        dataTest="dhis2-uicore-menuitem"
+        dense={true}
+        icon={<SpeechBubble />}
+        label="Show interpretations and details"
+        onClick={[Function]}
+      />
+      <MenuItem
+        dataTest="dhis2-uicore-menuitem"
+        dense={true}
+        icon={<Fullscreen />}
+        label="View fullscreen"
+        onClick={[Function]}
+      />
+    </Menu>
+  </Popover>
+</Fragment>
+`;
+
 exports[`renders correctly when fullscreen 1`] = `
 <Button
   dataTest="dhis2-uicore-button"
diff --git a/src/components/SystemSettingsProvider.js b/src/components/SystemSettingsProvider.js
index 29b966d78..86de25789 100644
--- a/src/components/SystemSettingsProvider.js
+++ b/src/components/SystemSettingsProvider.js
@@ -1,7 +1,10 @@
 import React, { useContext, useState, useEffect, createContext } from 'react'
 import PropTypes from 'prop-types'
 import { useDataEngine } from '@dhis2/app-runtime'
-import settingsQuery, { DEFAULT_SETTINGS } from '../api/settings'
+import settingsQuery, {
+    renameSystemSettings,
+    DEFAULT_SETTINGS,
+} from '../api/settings'
 
 export const SystemSettingsCtx = createContext({})
 
@@ -15,7 +18,13 @@ const SystemSettingsProvider = ({ children }) => {
                 systemSettings: settingsQuery,
             })
 
-            setSettings(Object.assign({}, DEFAULT_SETTINGS, systemSettings))
+            setSettings(
+                Object.assign(
+                    {},
+                    renameSystemSettings(DEFAULT_SETTINGS),
+                    renameSystemSettings(systemSettings)
+                )
+            )
         }
         fetchData()
     }, [])