Custom Themes is one of the new features shipped with February release so make sure you are updated before trying to come up with your own.


To create a new theme, first we need to understand what exactly is a theme and what it can do for us. A custom theme is a collection of files stored in a folder, it must contain a definition (QEXT) file, a main JSON file, and optionally any other assets you might need to support the custom theme such as CSS files, custom font files, images, etc.


Custom themes let users to quickly apply different levels of customization to their apps, some of you might be interested in having your custom color palletes, while someone else might just need bigger font size, both can be achieved with Custom Themes. Theme authors can target individual visualization objects via JSON and/or use a custom CSS to modify the sheet styles.


From Qlik Help


The custom styles can be defined in two ways:

  • In the JSON file you define the style for the individual visualization types, for example bar charts and line charts.
  • CSS styling is more general and flexible. You can, for example, style sheets, visualizations and extensions.


Creating a simple custom theme


I'll be using Qlik Sense Desktop for this example, please check the help page for instructions on how to install a Custom Theme in Qlik Sense Server.


  • Go to your extensions folder: C:\Users\[username]\Documents\Qlik\Sense\Extensions
  • Create a new folder, I'll call mine theme-helloworld
  • Create a new file and rename it to theme-helloworld.qext. The QEXT file is a definition file that contains a few lines, where only name and type are the only mandatory lines.


  "name": "Hello World theme",
  "description": "My first custom theme",
  "type": "theme",
  "version": "1.0.0",
  "author": "Arturo Muñoz"


  • Now, it's time for the JSON file. Create a new file, name it theme.json
  • Edit the theme.json file with your favorite text/code editor
  • My advice is to start your theme with the sample code you can find in Qlik Help so you can familiarize with JSON and it's properties:


  "_inherit": true,
  "_variables" : {
    "@greenColor" : "#61a729",
    "@text": "#4c4c4c"
  "color": "@text",
  "fontSize": "12px",
  "object" : {
    "title": {
      "main": {
      "fontSize" : "16px"
  "dataColors": {
    "primaryColor": "@greenColor"


  • The JSON file will change the primary color of your charts from Qlik dark blue to the custom green as defined in the variable at line 4 and will also modify the charts title to a font size of 16 pixels.

    This is a simple example but there are much more you can do with the JSON file, you could for example, define new color schemes for measures, change the axis', labels, legends font size and color and much more.

    Actually you could even load your custom CSS through the JSON file so you can target and hack any predefined style within your app, so you could modify object paddings, change font family, and so forth.


If you've followed the steps above you should have something like:


How to activate a Custom Theme?


Check how to apply a Custom Theme to your app in the animation below






Tips from the expert... and theme sharing!


I've asked my colleague Nabeel Asif for some tips since he created the Custom Theme based on Color Brewer that we are sharing  today (check the attachements). This is what he said:


All of our standard themes just give one sequential and one diverging gradient for measures, and two color schemes for dimensions. But you can actually define as many options as you like through the “scale” and “palettes” properties in the theme’s JSON.


For sequential and diverging gradients, Qlik uses seven colors to define a scheme. But you don’t actually need to specify all seven colors. Just define the two colors at the extremes, and Qlik does a nice job of calculating the rest. Of course, if you want very specific colors you can define them yourself.


Often apps will be designed with red representing something bad or dark colors representing higher values. To maintain this look as the user switches themes, you should follow these conventions in the JSON:

  • Diverging scales should be ordered from reddish hues to bluish hues.
  • Sequential scales should be ordered from dark to light. 


Please don't forget to always check Qlik Help for the most recent specifications.



steve.pngToday's Guest Blogger is, Qlik's Steven Pressland. Steven joined Qlik in 2016 as a Solution Architect. Prior to Qlik he was responsible for BI transformation and delivery across a number of Financial Services organizations. This experience and extensive product knowledge enables some of our largest enterprise customers to succeed at unlocking business insight through Qlik. Steven leads the global Advanced Analytics team within Pre-Sales and through this role brings us this update.  In this blog, Steve recaps the last 8 months of Qlik's latest enhancement to Qlik Sense and QlikView: Advanced Analytics Integration (AAI). He also shares the details on what's new with AAI in the February 2018 release including a sample on how it works.

Take it away Steve!


8 Months of Advanced Analytics Integration

Last June when Qlik Sense was released, it contained one of the biggest changes to the engine since the second generation data indexing engine engine was released with the launch of Qlik Sense in 2015. The server-side extensions API, more commonly referred to as Advanced Analytics Integration (AAI) was made generally available, providing a way for calculations to be externalized from the engine on demand as part of the user’s session.


Advanced Analytics Integration - Qlik Sense in 60


The capability and flexibility enabled developers to explore new use cases for their Qlik applications, and most importantly business users have more access to insights than ever before.


When we launched AAI, two open source connector projects were created. One for python and one for R. Supporting these two popular languages first, provided a way for users to connect to two of the most popular advanced analytics tools of choice. Since then, the R&D team has broadened Qlik's AAI projects by adding examples for C#, C++, GO and JAVA.


Over the last 8 months we have seen customers and partners deliver solutions using the out of the box sample R connector as well as create custom calculation engines to solve other calculation problems such as decryption and live data augmentation.


UK Reported Crime Demo App.jpg

UK Reported Crime Demo App



The next big milestone for AAI was the November 2017 release of QlikView, which brought the same AAI capabilities launched with Qlik Sense to QlikView. This gave QlikView customers a whole new set of opportunities for both old and new applications. The underlying technology for QlikView is the same as Qlik Sense, meaning you can share all the services already built with only a simple configuration step on your desktop or server. If you have not yet looked at how you can bring new a new perspective to your QlikView applications with Advanced Analytics Integration I will be presenting a session dedicated to AAI for QlikView at Qonnections 2018 (<- Customers and Partners sign up here), I hope to see some of you there.


The Qlik Community

As with many aspects of the Qlik product line, AAI’s success is made possible by the strong community who collaborate and share. The Qlik community space for advanced analytics integration is widely used and moving forward. This year we are planning to give it a facelift to make it easier to navigate and find information so more customers can make use of the technology in their businesses. If you have not yet got started with AAI or are experienced in the technology, do drop by and explore the resources available.


What’s new

This blog was written to coincide with the Qlik Sense February 2018 release, which is now generally available and includes the latest feature release for AAI which now supports whole table processing in the load script. A commonly requested feature is to be able to batch process algorithms for tasks such as model training and scoring. This was possible in a limited row by row capacity at launch, however with the new version we now support sending whole tables to and from the external calculation engine as a standard part of the application load script - made possible through a simple extension to the LOAD syntax.


So, how does this work?

When writing your application script there is now an extended syntax to the load statement, like the FROM or RESIDENT statements that have their specific uses. Qlik can now use the reserved statement, EXTENSION, to specify that the source of the loaded data table will be the result of an AAI function.


The following example calls an R script to score some input data using a table already loaded into the Qlik data model and returns a result:


 num(p,'##0.##') AS Predict_Score 
 R.ScriptEval(' … R Script Here … ',
 Rentals{RowID,Year,Month,Day,RentalCount,WeekDay,Holiday,Snow });

As you can see, the returned results are accessible to be processed using all the standard Qlik script functions providing a useful addition to the script syntax.


AAI Script Process.jpg


Where to Next?

There are lots of resources available to help you succeed with Advanced Analytics Integration, here are a few of the key links to explore:



  • This repository provides a server-side extension (SSE) protocol based on gRPC that allows you to extend the Qlik built-in expression library with functionality from external calculation engines. You can use external calculation engines in both load scripts and charts. In Qlik Sense and QlikView, you connect to these server-side extensions (SSEs) by defining analytic connections.
  • This repository provides a server-side extension (SSE) that allows you to extend the Qlik built-in expression library with functionality from R. You can use this in both load scripts and charts. In Qlik Sense and QlikView, you connect to this SSE R-plugin by defining an analytic connection.
  • The AAI Advanced Analytics Expression Builder is a Qlik Sense extension used to create advanced analytics expressions as master items and wrap these in to a pre-built visualization. These visualizations use native chart types and can be edited either as a master item or un-linked and customized.!/project/596f87f186a5cf7ec72e90e9

  • Qlik Sense extension which allows you to create charts to perform advanced analytics by simple drag and drop without complex scripting. This extension works on the top of the Advanced Analytics Integration (AAI) functionality with R.!/project/5979da222ef8975d99132f88

Hope you find this information useful.


Steven Pressland
Senior Solution Architect


On the demo team we end up working with both the Viz API to create and embed native Qlik Sense charts in apps, as well as creating custom components powered by the Qlik Engine using enigma.js, and we do this in Angular, React, and plain html, as we try to demo all of the ways that Qlik can be used. So after my last blog post (Starter project for developing QAP-powered apps with React and enigma.js) we had an idea on the demo team: let's try to unify all of our different custom components and templates. So we've been hard at work accomplishing that.

You may have seen Yianni's last blog post, qdt-components - A Components Library that can be used in simple Html, Angular 5 and React, introducing this effort. The goal is to have the qdt-components library include custom components powered by Qlik Engine, as well as a way to create and embed native Qlik Sense charts. Right now, the qdt-components library contains a few components, but we're not totally ready to start talking about all of them yet, so we're just sticking to the component that allows you to create and embed native Qlik Sense charts by interfacing with the Viz API.

The big addition since Yianni's post is that we've added a React template, so now we have an Angular 5 template, a plain html template, and a React template, all which load the qdt-components, which is pretty cool. This means that the components only need to be built once, but can be used in a project with almost any frontend stack. I say "almost" because in order to use the component that interfaces with the Viz API there's no getting around loading Angular 1.5 and RequireJS into the global namespace, which means they still have the chance to create conflicts. But you can choose not to use the component that interfaces with the Viz API if you don't have a need for native Qlik charts, and it will avoid loading all of the Capability API stuff, but if you choose to use it, you don't have to worry about writing any of the boilerplate you usually do when connecting to the Capability API.

Documentation, examples, and custom components are coming (and oh yea, we plan on using, but that's the update for now. You can check out the qdt-components library and the templates here - Qlik Demo Team · GitHub. And demos of each of the 3 templates below


Angular 5 with qdt-components

React with qdt-components

Simple html with qdt-components

And-the-winner-is-002.pngHey guys - it has been a little over a month since I introduced you to our first Qlik Community Twitter Contest within my 2017 year in review blog. I want to thank you for your contributions and was very pleased to see the number of awesome examples demonstrating Qlik in action. That being said, all contest submissions come to end and well, it's time to announce the this brief video to learn who it is and what the winner's 2017 Qlik Highlight was!





Can't see the video? Access to YouTube blocked by your organization or region? Download the attached .mp4 file to view on your computer or mobile device.

Do you ever use inline tables in your Qlik Sense app?  I do, especially when I need to add a small amount of data to an app that does not already exist in an Excel file or some other data source.  With the November 2017 release of Qlik Sense, manual entry was added in the Data manager.  With manual entry, users have the option to either manually enter their data into the table editor or paste their data into the table editor to add it to the Data manager.  I like this new small feature because it makes it very easy to copy Excel data or a table from a web page and add it as a table in the Data manager.  Let’s look at how it works.


From the Navigation menu, click on Data manager to open it.


Once the Data manager is open, click on the plus sign to add data.  On the left, there is an option for Manual entry as seen below.  Select Manual entry to open the Manual entry editor window.  Once the Manual entry editor window is open, users can enter a name for the table they would like to add as well as the field names and table entries.  To enter data, double-click on the cell and start typing.  You will find that as you enter data into the cells, additional rows and columns are added automatically.  Once you are done entering the data for the table, click the Add data button at the bottom right to add the table to the Data manager.  Users can also paste in rows from an Excel table or a webpage which is how I like to use it.  Simply, copy the rows you would like to add, select the entire data entry table by clicking a column or row until they turn orange (as seen below) and then paste the table/rows (Ctrl-P).

manual entry paste.png

After the data is added to the Data manager, it can be loaded and added to the data model.  Refer to Qlik Sense Help for shortcuts that can be used when using the table editor.  Now, if you are accustomed to creating inline tables via the script editor, you can still do that in the script editor using the syntax below:






This script will add a Products table with 2 fields, Product and Sales.  Five rows of data will be added to the Products table.






Manual entry allows users to manually enter data into the Data manager in a few easy steps.  Users do not need to remember the inline load script and they can load just the rows of data they need.  Manual entry is ideal when you have a small amount of data to add to an app.  When you have a lot of data, loading directly from the source or an Excel file may be easier.




Hi guys - in this edition of the Qlik Design Blog, I have a short video that briefly introduces you to some of the new features available in Qlik Sense February 2018. Some of the related features are already available in Qlik Sense Cloud and can be used immediately. (note: themes is not available in Qlik Sense Cloud). The software download is currently available to customers and partners who have signed up for the Technical Preview and will be made available for download in our customer downloads area this month.

Qlik Sense February 2018


Available shortly on the Qlik Help Channel - see more of these new features in action with our how-to tutorials.


Please let us know what you think by posting comments below.



What's New - Qlik Sense February 2018




Michael Tarallo (@mtarallo) | Twitter



Can't see the video? YouTube blocked by your Region or Company? Download the .mp4 to watch on your computer or mobile device.


qdt-components (Qlik Demo Team Components) is a library of components that we have developed in the demo team and that have been used in most of our mashups found in and It's a collection of filters, tables, barcharts, selection toolbars, or even simple getting/creating object methods from the Visualization Api. You do not have to worry about connection strings, loading Requirejs, jQuery etc. Everything is taken care for you! The library can be used in a simple html page by loading the qdt-components.js or in React and Angular2+ via npm.


Today, I will show you how to load a simple object and create a session barchart, in simple html and Angular 5


Simple Html

  • In your Html add
<script type="text/javascript" src="qdt-components.js"></script>
<div id="qdt1"></div>

  • In your Javascript code, add
var qConfig = {
   "config": {
      "host": "",
      "secure": true,
      "port": 443,
      "prefix": "/",
      "appId": "133dab5d-8f56-4d40-b3e0-a6b401391bde"
   "connections": {
      "vizApi": true,
      "engineApi": false
var QdtComponent = new window.qdtComponents.default(qConfig.config, qConfig.connections);
var element = document.getElementById('qdt1');
QdtComponent.render('QdtViz', {id: 'a5e0f12c-38f5-4da9-8f3f-0e4566b28398', height:'300px'}, element);


Simple html template: GitHub - qlik-demo-team/qdt-html-template: A simple html template that uses qdt-components

Live Demo: Simple html with qdt-components

Angular 5


  • Install the package
npm install --save qdt-components


  • Create new component by typing in the command line
ng generate component components/qdt-components --style=less


  • In your qdt-component.component.ts import the library and import or set the qConfig with the connection details
import { Component, OnInit, ElementRef, Input } from '@angular/core';
// import * as qConfig from '../../../qConfig.json';
import QdtComponents from 'qdt-components';
let qConfig = {
   "config": {
      "host": "",
      "secure": true,
      "port": 443,
      "prefix": "/",
      "appId": "133dab5d-8f56-4d40-b3e0-a6b401391bde"
   "connections": {
      "vizApi": true,
      "engineApi": false


  • Replace the class with
export class QdtComponentComponent implements OnInit {

   @Input() Component: Function;
   @Input() props: object;

   static QdtComponent = new QdtComponents(qConfig.config, qConfig.connections);

   constructor(private elementRef: ElementRef) { }

   ngOnInit() {
      QdtComponentComponent.QdtComponent.render(this.Component, this.props, this.elementRef.nativeElement);


  • After this, you can start using it in any other component. In the html add
<qdt-component [Component]="'QdtViz'" [props]="{id: 'a5e0f12c-38f5-4da9-8f3f-0e4566b28398', height:'300px'}"></qdt-component>


Template: GitHub - qlik-demo-team/qdt-angular-template: An Angular 5 template that is using qdt-components for connecting to Qlik …

Live Demo: Angular5



Branch: Qlik Branch

Github: GitHub - qlik-demo-team/qdt-components: React Components to be used with Angular2+ and React. Connects with the Capabili…

Npm: qdt-components



be9734868170ef50ac66fcd2b59da561.jpg.pngHey Guys - I have been meaning to do a video on this topic for many years and I finally got around to it! Over the years as I taught myself Qlik, I would dabble with the idea of incremental loading - but never really had a grasp on it as my data sets were always used for demos or they were quite small.....until I started building my Qlik Sense Retro-Gaming Dashboard.

1-30-2018 4-20-48 PM.png

(I use the incremental loading best practice to insert new video game pricing data daily - which allows me to view the pricing history of my collection for "Loose" and "Complete in Box" values). As I was building my app I had a ton of resources available to me but I never really found a decent video on this topic that simply explained what it was or how it is used. I figured I would create something short and sweet with a simplistic example from what I have learned, with hope it helps you understand incremental loading a bit better than I did! There are a few prerequisites you should be aware of, such as understanding what .QVD files are and what there purpose is. As well as basic data model design that include key and date fields which are used to identify new and changed records. I've included some samples files and resources at the end of this post to help.

Let me know what you think and please leave your questions or comments below. Enjoy!

Incremental Load


Michael Tarallo (@mtarallo) | Twitter






Sample Insert Only - Incremental Load Script


//Simple Insert - New Records from Source Data

// Get the last OrderID loaded into the .QVD
LOAD Max(OrderID) as MaxID
FROM [lib://IncLoadLocation (desktop-aura45o_mto)/sales_data.qvd] (qvd);

//Set a variable to be used in the SQL
Let MaxID = peek('MaxID',0,MaxKeyLoad);

//Get the latest data from the source where the OrderID in the Source is greater than the orderID in the .QVD
Load *;
SQL SELECT * FROM "Sales"."dbo"."Orders$"
WHERE OrderID > '$(MaxID)';

// Data is automatically concatenated if the data model has the sames fields
// CONCATENATE forces concatenation (in this example it is not necessary)
// Load all data from the .QVD
LOAD * from [lib://IncLoadLocation (desktop-aura45o_mto)/sales_data.qvd] (qvd);

//Store the new larger qvd file
// This will store the existing data and the new record and overwrite the existing .qvd
STORE orders into [lib://IncLoadLocation (desktop-aura45o_mto)/sales_data.qvd] (qvd);

// Exits script - used for debugging and troubleshooting - will not execute the next tab.
exit script;



Can't see the video? YouTube blocked in your region or office? - Download the .mp4 to watch on your computer or mobile device.


In case you want to perform this test with MS SQL - I added the SQL Queries and the MS SQL Database .bak file as well.

Qlik String functions are an extremely handy set of functions to clean, manipulate, and ultimately normalize data before (or after) loading it into an app. String functions ‒ Qlik Sense


I was working with a new data set recently, among other fields the data set contains addresses, something like this:


Abbey Road, London


Since the data set doesn’t have a dedicated city field I decided to apply Subfield() to extract the City as a separate field. Easy task, right? I use the comma as a separator to split the string.


Subfield (address, ',', 2) as City,


Shortly after we decided to expand the data universe of the app to include other countries in our analysis, we ended up having multiple sources with slightly different address formats:


Abbey Road, London

Paseo del Prado, s/n , Madrid

91, Rue de Rivoli, 75001, Paris


Not great news, right? Due to the variable number of commas in the address field I can no longer use subfield to manipulate the string, or maybe I still can use it.


Searching from the end of the string


Subfield function not only takes positive values for the third parameter, it also accepts negatives values. A negative value searches from the end of the string. This will help us to extract the City while keeping my script highly readable. The new function will be something like:


Subfield (address, ',', -1)


The function above will return the first portion of the string separated by the delimiter comma (',') searching from the end of the string, right to left. The newly created "City" field contains:






Right to left search in String functions

The use of negative values, or right to left search (remember the read will still be performed from the start of the string) also apply to other string functions:

  • Subfield

    Subfield('Abbey Road, London', 'o',-2) 

    Returns 'nd' (the second occurrence of 'o' starting from the end)

  • Index

    Index('Abbey Road, London', 'o',-2) 

    Returns 14 (the second occurrence of 'o' starting from the end)

  • FindOneOf

    FindOneOf('Abbey Road, London', 'oes',-3) 

    Returns ‘8’ because the search is for any of the characters: o, e or s, and "o" is the third occurrence starting from the right, and is in position 8 starting from the left.


I hope you find it as useful as I do.

AMZ @arturoqv

1-22-2018 9-48-55 AM.png

UPDATE: Attached are several demos, PDFs and a PPT that are useful to be shared externally for customers and partners alike.

By now it is common knowledge in the Business Intelligence and Data Visualization space, that the term Big Data doesn’t equate to one technology. That being said, it is also true that Big Data doesn’t relate to one scenario, use case or infrastructure. There can be many differences from one organization to the next. Since every situation is different, Qlik offers multiple techniques which can be used individually or in combination, to best meet the Big Data needs of a particular organization. One of these approaches is On Demand App Generation, commonly referred to as ODAG. ODAG was first introduced as an extension for previous releases, and is now built in to Qlik Sense starting with our June 2017 release. It benefits from continued enhancements with each release.

Our latest video from Adam  will show and tell you more.

"On Demand App Generation is a methodology that can be used in any situation where each user wants to explore their own slice of the data and it is now a built in function since the June2017 release of Qlik Sense. Big data analytics can now be approached through a shopping cart like process where dimensional data can be filtered at an aggregated high level and data slices automatically generated on-demand for further detailed analytics by users, all in a secure and governed manner." - Adam Mayer



On Demand App Generation

Helpful Resources

Who is Adam Mayer?

AM_round Green Circle_2.jpg


Adam joined Qlik in 2016 as a Senior Manager in Technical Product Marketing. He is responsible for delivering the company’s Internet of Things (IoT) go-to-market strategy. With a strong technical background in computing spanning over 20 years, underpinned by an incisive engineering perspective, Adam is an avid follower of new technology and holds a deep fascination of all things IoT, particularly on the data analytics side and finding new ways to make it as translatable, visual and understandable to as many people as possible.

"My first Qlik Sense app tracked my spend on car fuel where I geeked out on the rise and fall of pricing data!"

You can follow Adam on Twitter here: Adam_Mayer (@AdamMayerwrk) | Twitter

Can't see the video? Access to YouTube blocked?

Download the attached .mp4 to watch on your computer or mobile device

I've been doing most of my projects lately with React and enigma.js, and developing some general patterns along the way that I've been working into a starter project that I can use as a starting point. I'd like to share that with you today, and potentially start a discussion around the design decisions I've made thus far.


The starter project can be found at GitHub - fkabinoff/qlik-react-starter: Starter project for rapidly developing QAP-powered apps. It's still very much in development, but there's a decent framework and dev environment in place, as well as a few useful components.



The project uses enigma.js to interface with the Qlik engine, along with React, webpack, Babel, ESLint, Sass, and a few other goodies. Really, a pretty standard React app with enigma.js added. The qDoc, which is the name the enigma.js docs use for the connection to the Qlik app is created in a plain Javascript module and simply imported to any file that needs to use it.


I use react-hot-loader, which allows you to change react components without refreshing the page or losing state, and I really like it. It has it's problems, most noticeably to me that it doesn't play very nicely with higher order components, but the ability to change my React components and not have to reload the page or lose state helps me develop faster.


I'm using the latest Babel preset, which enables es2015, es2016, and es2017, and Babel plugins which enable decorators, spread syntax, and class properties. I can't believe we actually wrote Javascript before this stuff.


I use the very popular airbnb config for ESLint. It helps keep the code healthy and uniform.


I make use of reactstrap, a library of Bootstrap 4 components for React, and SASS for customizing and mixing in Bootstrap styles, as well as creating a few utility classes. I prefer using reactstrap over some of the more feature-rich React UI libraries, because I often find it creates more work trying to make the components of those UI libraries, such as Material UI, play nicely with how I want a component in a Qlik-powered app to function since in a Qlik-powered app the Qlik engine acts as a state machine, and many of the UI libraries with more features expect the state to be managed and changed by the client. Reactstrap gives me what I need, without being too opinionated about it.


I use the "render prop" pattern in place of higher order components. The render prop pattern is simply passing a component as a prop to another component for that component to render it. It basically works like a higher order component does, but to me it's a bit simpler, a little more flexible, and doesn't mess with react-hot-reload or PropTypes checking.


Notably, I don't use a state manager like Redux or MobX, and this may be my most contentious decision. To me, the use of a state manager in most instances is redundant when building a Qlik-powered app. Qlik already manages my state, and shares it between components. I hardly, if ever, have state that needs to be managed outside of Qlik in my Qlik-powered apps, and using a state manager forces me to do extra work to keep the client state and Qlik state in sync. I don't like it.


It would be very interesting to hear what you think about these design decisions, and the decisions that you've made with your own Qlik projects.



Now, let's take a look at the actual components. There are currently 4 Qlik-specific components, but I expect to add more as I continue developing this. I tried to design the Qlik-specific components to expect props which are identical to values defined in Qlik docs, and pass down values directly returned by the Qlik engine, in order to standardize as much as possible. Though in some instances, I broke that rule. For instance, since the QlikObject wrapper, which I'll talk about in a moment, is really only designed to work with an object that fetches one page, it didnt make sense to pass down the qDataPages returned by the Qlik generic object getData method. Instead, I simply pass down the object at the first index of qDataPages.



The QlikObject component implements the render prop pattern, and contains the logic to create and manage a Qlik generic object and its state. It passes down the Qlik generic object information to the component defined in the Component prop, which is responsible for rendering something.


The QlikVirtualScroll component implements the render prop pattern, and paginates data on vertical scroll so only data in view gets rendered. It passes down a subet of the qMatrix to the component defined in the Component prop, which is responsible for rendering something. It is used by the QlikFilter and QlikTable components.


The QlikFilter component renders a dropdown that acts as a Qlik Sense filter. It's meant to be used as the `Component` prop of a `QlikObject` component a type of `qListObject`. This component doesn't need to be passed any props other than the props passed to it by `QlikObject`.


The QlikTable component renders a table. It's meant to be used as the `Component` prop of a `QlikObject` component with a type of `qHyperCube`. This component requires a prop `columnWidths` to be passed to it, defining the widths of the columns of the table. This prop should be passed using the `componentProps` prop of the `QlikObject`.

Finishing up

Go to GitHub - fkabinoff/qlik-react-starter: Starter project for rapidly developing QAP-powered apps, download the zip, run npm install, and npm run dev, and you can check out the QlikFilter and QlikTable components in action, and check out the code. I'll be adding more components and styles as I'm still pretty actively developing it, so watch the repo if you're interested, and let me know what you think.

Jennell McIntire

Qlik Sense Histogram

Posted by Jennell McIntire Jan 12, 2018

What is a histogram?  A histogram is a chart that allows you to visualize the distribution of data over a continuous interval or certain period.  It is made up of bars like a bar chart but instead of displaying actual counts against a dimension, a histogram displays the frequency at each interval or bin allowing you to see where the values are concentrated and where there are gaps or odd values.  A histogram is also different from a bar chart in that it does not need measures.  Only a single numeric dimension is needed to create a histogram.  Once the dimension is added to the Qlik Sense histogram chart, the frequency is automatically calculated.


Let’s look at an example, in the histogram below, the dimension BMI (body mass index) is used to view the frequency.  After BMI was added to the chart, Qlik Sense automatically created the BMI bins based on the frequency distribution.  This chart shows that BMI is concentrated in the range 21 <= x < 22.75 (21 to 22.75, but not including 22.75).


The Qlik Sense histogram chart has some properties that can be used to customize the histogram.  There is the ability to set the number of bars to a maximum number or set the width of the bars if you would like the bars to be even intervals.  Qlik Sense Help has an example of a histogram using even intervals to show temperature.

num of bars.png               bar width.png


In the histogram above, the number of bars is set to 10.  When the bars are set to Auto, Sturges’ formula is used to determine the bins and this may change based on selections.


A histogram chart is ideal for a large amount of data when you need a quick visualization of frequency.  It is easy to create since only one dimension is required.  The key to remember is that the dimension field must be numeric.  Try it out with your numeric dimensions in your next Qlik Sense app.  If you are using QlikView, you may be interested in Henric Cronström’s blog Recipe for a Histogram on how to create a histogram in QlikView.  Also, check out Arturo Munoz’s blogs on the Distribution Plot chart and the Box Plot chart.  You may also find these helpful in your next Qlik Sense app.




ny2018.pngWell guys - where do I begin? – Ah I got it, Happy New Year! <sigh> It feels like only yesterday that I was writing my first blog for 2017. However, after a long break, I’m excited to get back to work and contribute towards another prosperous year at Qlik! I didn’t want this to be another one of those “Year-in-review-type” posts……I cleverly disguised it to highlight some of our product achievements during 2017. Think about it as a sitcom clip-show. So much Qlik goodness has transpired over the past year not only is it difficult to cover everything that has happened with the product, but as a consumer, I know it's difficult to keep track of it all, so I ‘ll do my best to summarize and consolidate where I can. This post is a bit long - so for some of you, I expect you to bookmark it and use it for later reference if needed.

ENTER TO WIN $50 Amazon Gift Card - Rules Below

So, let’s begin.


For those of you who want the short, short version:


  • Qlik GeoAnalytics
  • Qlik Sense 3.2
  • QlikView Converter
  • Qlik Sense Chat Bot
  • Data Connectivity
  • Qlik Sense June 2017
  • Advanced Analytics Integration
  • Qlik Sense September 2017
  • Qlik Sense November 2017
  • Qlik Sense Mobile
  • Qlik's Associative Difference


Qlik GeoAnalytics


Qlik GeoAnalytics Datasheet1-3.jpgIn January of 2017 – we kicked off the then new year with an acquisition of our Sweden-based partner, Idevio, creator of Idevio Maps. We introduced the recently acquired product as Qlik GeoAnalytics. Currently available as an extension for both Qlik Sense and QlikView, Qlik GeoAnalytics goes beyond traditional “points on a map” and adds a broader range of capabilities to support advanced geoanalytic use cases. During 2018 (no specific time-frame yet) we plan on integrating Qlik GeoAnalytics directly into Qlik Sense, so stay tuned.


ICYMI: Introducing Qlik GeoAnalytics


Qlik Sense 3.2



Soon after, in March 2017 - we announced our first release of Qlik Sense for the year, version 3.2. 3.2 added the ability to easily create time-based measures (Calendar Measures), included additional chart options to support custom colors and color assignments, introduced the QlikView Converter and added a new configuration to improve the performance and stability of multi-node deployments (Shared Persistence)

ICYMI: Introducing Qlik Sense 3.2



The QlikView Converter


ui-qlikview-converter-example-01.png With version 3.2 we included a utility found in the Dev Hub that simplifies converting a QlikView document (.qvw) over to a Qlik Sense app (.qvf). You simply upload your .qvw to the converter to be analyzed, and it will extract the data model, script, measures, dimensions, expressions, variables and even compatible visualizations. The user can then choose what they want to convert to create a starter Qlik Sense app. Next they can create new or modify existing visualizations using the assets that were already available in QlikView.


ICYMI: QlikView converter - Qlik Sense - YouTube


Qlik Sense Chat Bot


1.pngApril 2017 set a new milestone for Qlik by pushing the boundaries of analytics.  We demonstrated the art of the possible using the Qlik platform, its awesome APIs, and various 3rd party technologies - to create the first ever Qlik analytics chat bot. Simply stated, imagine getting your answers to your business questions by asking your digital assistant. Since the original bot debuted at the Gartner BI Bake-off and Qonnections there has been tremendous interest in this concept, which has evolved rapidly over the 2nd half of 2017. There is now a new community group: with many supporting resources and our own Todd Margolis is leading the charge to help enable our community to take advantage of our two open-source Qlik Bots.  Whether you’re a business user and want quick and easy access to your KPIs on the go or you’re a developer and want to extend them with new capabilities or integrate Qlik into your existing bots, we’ve got you covered.




Data Connectivity

cloud+blog+2.pngOver the course of 2017 Qlik Sense and Qlik Sense Cloud had many improvements, especially in the area of connectivity. In May we introduced the first integration of our Web Connectors package to Qlik Sense Cloud – starting with access to Twitter, Facebook and Google Analytics.  Then in July we introduced on premise connections from Qlik Sense Cloud starting with MS SQL as well as the Web file connector. During 2017 we delivered over 20+ connectors to Qlik Sense and Qlik Sense Cloud Business including Dropbox, REST, Amazon Redshift, YouTube and many more.






In addition to the aforementioned connectivity we also debuted our new release schedule and product naming convention when delivering Qlik Sense June 2017. No more dot releases for us – new releases are now identified by the month they are delivered in. June 2017 brought us new visualizations (Histogram, Distribution and Box plots), enhanced visual data preparation features that support data profiling and data quality and a new Advanced Analytics integration framework – allowing you integrate with advanced analytics engines such as R and Python.




Qlik Advanced Analytics Integration (AAI) enables direct server to server data exchange between Qlik Sense and 3rd party calculation / analysis engines via a connector or what we also call a plugin. So for example, a specific forecasting function that is part of an R library can now be called from within Qlik script and chart expressions and calculated on the fly. Passing the results back to the Qlik analysis engine and subsequent visualizations. With this capability we now support the APIs that provide connectivity to such engines and provide starter connector projects for R and Python.


ICYMI: Introducing Qlik Advanced Analytics Integration


Qlik Sense September and November 2017


9-5-2017 1-20-11 PM.png

Continuing our commitment to deliver iterative improvements and features every 10 weeks, we released our September and November 2017 releases, which introduced our new Waterfall chart, continuous transformations using visual data preparation, our Qlik Sense Mobile app, visualization and navigation improvements and the introduction of our extension certification pilot.






Qlik Sense Mobile (offline)


Originally released to select participants in June, the Qlik Sense Mobile app for iOS became available to customers and partners in the Apple App Store later in the year. This iOS app enables its users to connect to their Qlik Sense Enterprise Server and download a local copy of their Qlik Sense app directly to their iOS device where they can analyze data on the device just as if they were connected to the server, allowing them to take Qlik Sense with them on the go in a disconnected state. (at this time Qlik Sense Mobile is for iPad only – a version for the iPhone is expected to be release early this this year.)





Qlik’s Associative Difference


assoc_thumb.pngFinally, analytics is more than just creating charts, it’s about finding answers. Therefore, I’d like to give an honorable mention to our team, who has created resources to help our prospects, customers and partners clearly understand the benefits of Qlik’s Associative Difference, powered by our patented associative technology. Sometimes referred to by many different names (Associative Experience, Associative Model, Green-White-Grey), Qlik’s Associative Difference separates us from those traditional query-based visualization tools. Qlik’s Associative Difference allows you to explore data freely in any direction, automatically associating every dimension in the data model which visually reveals how the data are related using the colors green, white and grey - AND -  without leaving any data behind.




Well guys – that’s it – your Qlik 2017 Year In Review – oh wait. - I said I wasn't doing a "year-in-review" post, ah @#$%&!.


Personal Giveaway Rules:


Do you have some interesting Qlik highlights or discoveries during 2017 that you would like to share? We want to know. Post them in the comments below OR if you would like to participate in my personal giveaway with a chance to win a $50 Amazon Gift Card (claim code) post a tweet using twitter with your 2017 Qlik highlight or discovery and tag me using @mtarallo along with the hashtag:


#Qlik2017Highlights will then be entered into a reviewed, random drawing to receive $50 Amazon Gift Card(claim code). Winner will be selected using Qlik's Twitter Connector and Qlik Sense app which will draw a random tweet using the hashtag: #Qlik2017Highlights. Winner will be announced on Twitter by @mtarallo on February 6th 2018 [UPDATE: Feb 13th 2018] and in the Tuesday edition of the Qlik Design Blog. Entry must be an interesting or valid Qlik highlight or discovery - if not it will be discarded and the next entry will be selected at random.


Contest starts Tuesday Jan 9 2018 and ends on Tuesday Jan 30 2018. We want to hear from you!





Michael Tarallo (@mtarallo) | Twitter



Last month I talked about our new QlikBotNode, setting it up and getting it ready for Telegram Qlik Sense Bot with Node.js and Enigma.js.


Today, I will talk about the steps needed to make your bot available for Microsoft Skype as well!


Assuming that you have already forked the code from GitHub - qlik-bots/QlikBotNode: QlikBotNode is a server build in Node.js, Express.js, Enigma.js and MySql that connects … and you have already went through the previous tutorial and set up the Telegram bot.


  • First you need to "Register a Bot with Bot Service". Login to the Azure Portal
  • Click the New button found on the upper left-hand corner of the Azure portal, then select AI + Cognitive Services > Bot Channels Registration.
  • Click the Create button to start the creation process.



  • Enter a Bot Name as you want to appear in your contact list
  • You can use the free Pricing Tier for testing
  • For the Messaging Point add you full route like https://{your-server}/api/sense-bot/microsoft/
  • You can skip the Application Insight for now
  • Once registered, go to settings and get the AppId and the Password. You will need to add them in your environmental variables



  • Click on Manage to get the password



  • Put the AppId and Password in your Environmental variables.
  • For Windows, go to "Control Panel" -> "System" -> "Advanced System Settings" -> "Environment Variables"
  • - For Linux, from your directory (~), type "nano .bash_profile" or "vim .bash_profile" and enter the variables there like
  • export SKYPE_BOT_ID_SCV=''
    • export SKYPE_BOT_PASSWORD_SVC=''
  • While still in settings, go to "channel" and add skype.

Thats it!

For more Details on Register a bot with Bot Service (


  • Type help for all of the available commands.



  • Click on Salesforce to get the available commands for the Salesforce App and then click on the Dashboard to get a list of KPIs



  • Click on CIO Dashboard and then on Management



  • - If you want to change your language click on Language and select one of the available ones. So far we have only 3, English, Spanish and Greek but please feel free to add as many more as you want


That's it!


Make sure you follow:





It's time for the end-of-the-year in review post, it's time for the cream of the crop.


During 2017 six main authors and a respectable number of guest bloggers posted a total number of 85 articles (plus this one).


We wrote 39,822 words (7,819 distinct words), that’s 15% more than the number of words we wrote previous year. We wrote the word “Qlik” 566 times, an absolute record. You contributed 695 times to the success of this blog in the comments section, we truly appreciate your feedback and comments!




Most popular posts in 2017


Most read/visited posts

Don't be the last one to read it!


  1. Qlik Sense September 2017 - What's New
  2. Quotes in Set Analysis
  3. Push the Boundaries of Analytics - Qlik Sense Bot (video)
  4. Take a look at Qlik Sense June 2017
  5. Introducing DAR mashup template


Most commented posts of the year

Everyone is buzzing


  1. Quotes in Set Analysis
  2. Introducing Qlik Sense 3.2
  3. Take a look at Qlik Sense June 2017
  4. Qlik Sense September 2017 - What's New
  5. Push the Boundaries of Analytics - Qlik Sense Bot (video)


The underdogs 2017

They worth a second read.


  • Qlik Sense WordPress Plugin
    The world most popular CMS and the most powerful Analytics platform combined? it seems like a perfect match. This blog post is capturing a lot of comments, check it out and join the conversation.
  • Rank Function
    Some of the old Qlik functions still have secrets, check this post to learn what you are missing from the Rank function.
  • Intro to Qlik Open Source Software
    It feels great to contribute to the Open Software community, read what Qlik has to offer!
  • Salesforce and CIO dashboard mashups available to the public
    You can use these examples as templates or just dissect them into pieces to learn more about Qlik APIs and how to build impacting data sites.



I wish you an enjoyable New Year countdown!

Arturo (@arturoqv)

Filter Blog

By date:
By tag: