Access the 30-day Sisense trial here

In this knowledge-base article you’ll learn:

• What’s included in the Sisense free trial

• Key benefits for product teams, analysts & executives

• Link to register for your trial

• Pro tips to make the most of your 30 days

Why Sisense? Quick Highlights

What You Get in the 30-Day Test Drive

1. Full Sisense Fusion platform – data connectors, Elasticube modeling, dashboards, Pulse alerts, AI features.

2. Guided walkthroughs – in-app tours that teach you to connect data and build visualizations fast.

3. Sandbox + bring-your-own-data – upload CSVs or hook into cloud warehouses to test real scenarios.

4. Support resources – access to docs, webinars and RAPID BI experts during your evaluation.

5. No setup headaches – the environment is provisioned instantly in the cloud, so you can focus on insights, not servers.

How to Start Your Sisense Free Trial via RAPID BI

1. Start your 30-Day Sisense Test Drive

2. Create your workspace – enter basic details and choose sample or custom data.

3. Follow the in-app checklist – connect a data source, build your first data model, and publish a dashboard.

4. Embed or share – generate an embed token or invite team members to experience live analytics.

5. Book a strategy session with RAPID BI – our consultants can help you plan architecture, proof-of-concept KPIs, and license sizing.

Pro Tips to Maximise Your 30 Days

• Start with one real use-case you want to ship in production; work backwards from user stories.

• Explore Compose SDK code samples to see how quickly you can embed charts in React, Angular or plain HTML.

• Test row-level security early—Sisense’s JWT-based approach fits multi-tenant SaaS out of the box.

• Benchmark load times with your own data volume so you can tune Elasticube builds.

• Leverage AI Explain to auto-surface drivers behind metric changes (great demo value).

Here is the solution we provided them:

You can try the following code to generate and add plotLines and Labels to either xAxis or yAxis at any given positions (for yAxis, values, or xAxis, category indexes). The following looks for the position of xAxis categories and then adds lines and labels to them.

function makePlotLine(color, style, width, position) {
  return {
    color: color,
    dashStyle: style,
    width: width,
    value: position,
    zIndex: 5
  }
}

function makeLabel(labelText, labelColor, position) {
  return {
    value: position,
    color: '#fff',
    label: {
      text: labelText,
      style: {
        color: labelColor
      }
    }
  }
}

const categoriesWithLine = ['07/2011', '01/2012']
widget.on('processresult', (w, args) => {
  args.result.xAxis.plotLines = []
  args.result.xAxis.plotBands = []
  for (let i = 0; i < categoriesWithLine.length; i++) {
    const currentCat = categoriesWithLine[i]
    const indexOfCurrentCat = args.result.xAxis.categories.indexOf(currentCat)
    const plotLine = makePlotLine('green', 'ShortDash', 2, indexOfCurrentCat)
    const label = makeLabel(`This is a label on ${currentCat}`, 'black', indexOfCurrentCat)
    args.result.xAxis.plotLines.push(plotLine)
    args.result.xAxis.plotBands.push(label)
  }
})

widget.on('ready', (w, args) => {
  $('svg .highcharts-plot-bands-labels-0', element).insertAfter('svg .highcharts-plot-bands-0', element)
})

LINES:

This code allows you to set a benchmark on your graph to visually assess whether Key Performance Indicators (KPIs) are being met. By establishing a benchmark, you can clearly see how your data points compare against a predefined standard or goal. This is particularly useful for performance tracking and decision-making, as it enables you to:

• Quickly Identify Trends: See if your data consistently meets or falls short of the benchmark over time.
• Highlight Areas of Improvement: Easily spot periods where performance dips below the expected level.
• Make Data-Driven Decisions: Use visual insights to inform strategic actions and adjustments.
• Communicate Effectively: Share clear, visual representations of performance with stakeholders, making it easier to convey whether objectives are being achieved.

By incorporating benchmarks into your graphs, you enhance the utility of your visual data analysis, providing a straightforward way to monitor progress and take timely corrective actions if needed.

widget.on('ready', (se, ev) => {
  $('svg .highcharts-plot-bands-labels-0', element).insertAfter('svg .highcharts-plot-bands-0', element)
})

widget.on('processresult', (w, ev) => {
  ev.result.yAxis[0].plotLines = [{
    color: 'green',
    dashStyle: 'ShortDash',
    width: 2,
    value: 5,
    zIndex: 5
  }]

  ev.result.yAxis[0].plotBands = [{
    from: 5,
    to: 10,
    color: '#fff',
    label: {
      text: 'Benchmark',
      style: {
        color: '#000'
      }
    }
  }]
})

BANDS:

This code allows you to set color-coded bars on your graph. This color-coding provides an immediate visual cue about performance levels:

• Green Bars: Indicate that you are performing well and meeting or exceeding your targets.
• Yellow Bars: Suggest that there is room for improvement. Performance is close to target but not quite there yet.
• Red Bars: Signify that performance is below expectations and needs significant improvement.

By using these color-coded bars, you can:

• Quickly Assess Performance: Instantly see which areas are doing well and which need attention.
• Prioritize Actions: Focus on red and yellow areas to improve overall performance.
• Enhance Understanding: Make it easy for stakeholders to grasp performance status at a glance.
• Improve Communication: Convey performance levels clearly and effectively through visual representation.

Incorporating color-coded bars into your graphs enhances their functionality, making it simpler to monitor performance and take necessary actions based on visual feedback.

widget.on('ready', (se, ev) => {
  $('svg .highcharts-plot-bands-labels-0', element).insertAfter('svg .highcharts-plot-bands-0', element)
})

widget.on('processresult', (w, ev) => {
  ev.result.yAxis[0].plotBands = [{
    from: 5,
    to: 10,
    color: '#f2f2f2',
    label: {
      text: 'Average',
      style: {
        color: '#000'
      }
    }
  },
  {
    from: 10,
    to: 20,
    color: '#00ff00',
    label: {
      text: 'Above Average',
      style: {
        color: '#000'
      }
    }
  }]
})

let widgetTitles = prism.activeDashboard.widgets.$$widgets.filter((w) => { return w.title === 'RICHTEXT_MAIN.TITLE'}).map((w) => { return w.oid })
for (let i = 0; i < widgetTitles.length; i++) {
  $(`[widgetid="${widgetTitles[i]}"]`).find('widget-header').css('visibility', 'hidden')
}

This tool allows you to select the desired dimension or measure to display in a charts or widgets.

The Adaptive Switcher is accessed by placing a drop-down menu on your dashboard that can apply to some or all widgets in a dashboard. This menu will show the different dimensions that have been set up by the designer for you to switch between, and you can select the desired dimension to display.

If the Adaptive Switcher has not been implemented in your dashboard, you may need to speak with your dashboard designer or the person responsible for creating and maintaining the dashboard or your Sisense environment. They will be able to engage with RAPID BI to get the Adaptive Switcher set up for you to use.

• adding the value of the current item to the previous item,
• where the item isn't the first item in the list.

This can be achieved on a widget level for each series with the following script.

widget.on('processresult', (widget, args) => {
  args.result.series.forEach((series) => {
    for (i = 1; i < series.data.length; i++) {
      series.data[i].y += series.data[i - 1].y
    }
  })
})

// making the prism dom injector look more friendly.
const $dom = prism.$injector.get('ux-controls.services.$dom')

// example of how information can be injected into the modal.
const info = 'hello world'

// creating HTML to be displayed by the modal
const popupHtml = `<div> ${info} </div>`

// setting up settings object for modal injector
const settings = {
  template: popupHtml,
  scope: 'fake',
  css: 'resize-modal',
  id: 'myModal'
} // Hack for $dom service

// create the modal using settings
$dom.modal(settings)

Download Docker. This can be installed on Windows.

Open a cmd prompt and enter the following

docker pull phpmyadmin

This will install the PHPMyAdmin docker image

In the command prompt enter the following, changing IP with the IP of the MySQL server (this will work for MySQL hosted on AWS amongst others).

docker run --name myadmin -d -e PMA_HOST=IP -p 8080:80 phpmyadmin

Now access PHPMyAdmin in a web browser at http://localhost:8080/

Full documentation on docker commands for PHPMyAdmin is at: https://hub.docker.com/_/phpmyadmin