The word Scrum comes from rugby. The tight formation where players pack together, heads down, working as one unit to move the ball forward. The image fits. In a Scrum team we also move as one unit, relying on communication, transparency, and trust in each other's capabilities to reach a shared goal.

Qlik delivery is a good home for that mindset. Migrations, new applications, reload optimization, data modeling. The work is complex by nature. Requirements shift the moment users see their data, source systems behave unpredictably, and the right solution is rarely the one sketched on day one. Waterfall: discovery. Design. Develop. Test. Looks tidy on paper, but it breaks when the data does not match the design document, or when a client realizes mid-project that the dashboard they asked for is not the one they actually need.

Scrum holds up because it rests on three pillars: transparency, inspection, and adaptation. Transparency means the work is visible. Jira (or your preferred Project Management Tool) is the single source of truth, and if a deliverable is not there, it does not exist. Inspection happens in the events: daily scrums, sprint reviews, retrospectives. Adaptation is what makes inspection worth anything. When a gateway server goes down or a client reshapes their reporting needs, the backlog shifts, and the sprint keeps moving.

The team itself is small by design. Ten people or fewer, three roles, no hierarchies. The Product Owner maximizes the value of the product and owns the backlog deciding which reports and data sources matter most. The Developers - Qlik developers, data engineers, and UAT support create a usable increment each sprint and hold themselves accountable, as a team, for what ships. The Scrum Master establishes the framework and removes the blockers: access requests, gateway issues, client dependencies that stall the work.

Everything is time-boxed. Sprint planning commits the team to specific apps, QVDs, or migration tasks. The daily scrum is fifteen minutes; progress, blockers, plan for the day; a missing credential surfaces here, not a week later. The sprint review is where working increments get demoed to stakeholders, and the feedback reshapes what comes next. The retrospective, for the team only, is where the process itself improves. And an item is only done when it meets the Definition of Done; for Qlik, that means the script runs cleanly on schedule, UAT passes, documentation is updated, and the reload is in the operations reference. Anything less goes back to the backlog.

The framework only works if the team lives the five values: commitment, focus, openness, respect, and courage. The courage to say an item is not done, to ask the question that feels obvious, to push back when the plan no longer fits the reality.

There is a story in Scrum: The Art of Doing Twice the Work in Half the Time about Toyota's assembly line: any worker can stop the whole line when a problem appears, and the team swarms to fix it on the spot. One defect, solved once, forever. The alternative is hundreds of cars shipped with the same flaw. The principle applies to our work too. A defect caught inside the sprint costs far less than one caught in production, and doing it right the first time is almost always faster than fixing it later.

Partial Scrum is not Scrum. Skipping the retrospective, letting the Product Owner drift from the backlog, stretching the daily past fifteen minutes. These turn the framework into ceremony. Either keep all the parts, or call it something else. As Schwaber and Sutherland write in the 2020 Scrum Guide: "Scrum exists only in its entirety and functions well as a container for other techniques, methodologies, and practices."

For Qlik delivery, that entirety is what gives us a way to plan without overcommitting to the plan. We commit to the sprint, we inspect the results, we adapt. The product gets closer to what the client needs with every cycle and not further away.

Further reading: The Scrum Guide (Schwaber & Sutherland) · Scrum: The Art of Doing Twice the Work in Half the Time (Sutherland).

Table of Contents

• What's new in Qlik GeoAnalytics Data Package 26.04
• System requirements notes
• Downloads

The following release notes cover the versions of Qlik GeoAnalytics Data Package released in April 2026. For questions or comments, post in the Product Forums or contact Qlik Support.

What's new in Qlik GeoAnalytics Data Package 26.04

• Adds and updates several Admin Areas for the Location service.
• Adds Regions (Admin1) and Community Development Councils (Alternative Admin1) Areas for Singapore.
• Updates Postal Code Areas for USA and Germany.

A complete change log can be found in the readme file included in the release zip file.

System requirements notes

See the system requirements for GeoAnalytics Server.

Downloads

Qlik GeoAnalytics Data Package 26.04 zip file can be found on the Product Downloads under the category "Qlik Data Analytics".

The installation guide is available as an attachment for this document.

About Qlik

Qlik converts complex data landscapes into actionable insights, driving strategic business outcomes. Serving over 40,000 global customers, our portfolio provides advanced, enterprise-grade AI/ML, data integration, and analytics. Our AI/ML tools, both practical and scalable, lead to better decisions, faster. We excel in data integration and governance, offering comprehensive solutions that work with diverse data sources. Intuitive analytics from Qlik uncover hidden patterns, empowering teams to address complex challenges and seize new opportunities. As strategic partners, our platform-agnostic technology and expertise make our customers more competitive.

qlik.com

This guide walks you through building a feature-rich spreadsheet that looks and feels like Excel in Qlik Sense using the Spreadsheets extension (first demoed at Qlik Connect 2025).

Check it out as a video tutorial or keep reading:

Step 1: Add the Spreadsheets Extension

1. Open your Qlik app and go to the Assets panel.
2. Head to Custom objects > AnyChart 4, and drag AnyChart Spreadsheets onto your app's sheet.

This creates a basic spreadsheet looking as follows:

Step 2: Add Data

1. Select the object, open the Properties panel, go to Data, and click Add.
2. Choose the new data section, enable Create synced sheet, and click Edit data.
3. Add the dimensions and measures you want to use.

This creates one more sheet, titled DataSheet1, populated with your data.

Step 3: Format Your Spreadsheet

1. To keep things clean, feel free to delete the empty sheet created by default, titled Sheet1.
2. On DataSheet1, select your table area, head to the INSERT tab, and click Table. Confirm with OK.
3. Apply formatting as needed, all in a familiar Excel-like interface. For example:
   - Resize rows and columns.
   - Change alignment and font settings from the HOME tab.

Step 4: Add Charts

You can also add charts within the spreadsheet's sheets, just like in MS Excel.

1. Select your data, open the INSERT tab, and choose Insert Chart.
2. Select a chart type, click OK, and place the chart where you need it.

Step 5: Save Changes

1. Whenever you need to save everything you have done, open the USER tab and click Save to app.

Step 6: Apply Selections & See Your Spreadsheet in Action

1. Apply filters or selections in your Qlik app.
2. The spreadsheet updates instantly. Charts, tables, and formulas adjust to the selected data in real time.

This works as the spreadsheet is fully connected to Qlik’s associative engine.

Optional: Export to Excel

If you want to work outside of Qlik, such as in Microsoft Excel or Google Sheets, feel free to export the entire spreadsheet as an .xlsx file:

1. Go to the FILE tab, choose Export, and select Excel format.
2. Click Export Excel File, enter a file name, and confirm with OK.
3. The file downloads immediately, ready to open in Excel or another compatible tool.

Here's how the downloaded XLSX file looks when opened in MS Excel:

Done

You now have a reactive spreadsheet, built with live Qlik data, ready to expand, customize, or share.

Helpful Links

• Download the extension
• Explore the demo app (view live or download QVF)
• See the documentation
• Request a personalized live demo

A while ago, I conducted an internal research project with my colleagues @AlaneMiguelis, and Dr. @priscilarubim, aiming to validate the accuracy of a Two-Sample T-Test in Qlik by comparing it with the medical research gold standard: R. While we explored various hypothesis testing methods, we prioritized formalizing our findings on the T-Test. Recently, we decided to make this document available to the whole community.

The focus of our project was to assess whether the statistical results produced by Qlik matched those generated by R, particularly for the Two-Sample T-Test. Our methodology involved rigorous data analysis and repeated testing to ensure the reliability and consistency of our results. Through our detailed comparative analysis, we aimed to provide insights into the robustness of Qlik’s statistical capabilities. The code and dataset is available in a Git repository for those who want to reproduce the study.

Here is the abstract of our study. The full document can be accessed through the link at the end of this post.

ABSTRACT

Objective

The statistical determination of a large or small difference between two groups is not based on an absolute standard, but is rather an evaluation of the probability of an event.1,2 In the field of medical research, it is common to use statistical software for descriptive statistics as well as to perform statistical tests.3 However, most software provides ready-to-use functions, and the researchers have almost no information as to how those statistical tests are calculated inside those functions. This article evaluates the accuracy of two-sample Student’s t-test using Qlik analytics software. The gold standard used for this evaluation is the set of standard t-test functions available in R software, a widely used, robust, and reliable statistical software.5–7

Materials and Methods

The tests performed in this evaluation used a subset of Framingham heart study data. The dataset contains data on 4,434 anonymous participants, collected in three periods apart from each other by 6 years from 1956 to 1968. Five t-tests with 2 scenarios each were performed in Qlik analytics and in R and the results compared.

Results

In general, the results for multiple statistics obtained in Qlik analytics match the ones found in R for multiple scenarios: small and large sample sizes, small and large p-values, assuming and not assuming equal variance.

Discussion

Although Qlik analytics matches all statistics for t-test found in R, the p-value only matches up to four decimal points, which is concluded to be enough for testing hypothesis since the conventional levels of significance do not go lower than 0.1.

Conclusion

This research concluded that Qlik analytics can be used for two-sample t-tests in multiple scenarios.

Keywords: Qlik, t-test, r language, Framingham.

Link for the full article: Comparing Qlik Analytics and R Software for Accurate Two-Sample T-Tests Research Paper (ipc-global.com)

Introduction

QlikView > Qlik Sense > Qlik Cloud...
Replatform is challenging and sometimes, different platforms have to coexist and interact to each other.

In this article I will show how can you call QlikView Tasks from Qlik Sense - and potentially from Qlik Cloud - using PowerShell Scripts.

Requirements

• QlikView and Qlik Sense Servers must be accessible to each other
• Qlik Sense Service User Account must have QlikView QMC rights to execute tasks
• Qlik Sense Legacy Mode enabled - More info: Disabling standard mode | Qlik Sense on Windows Help
• PowerShell installed and enabled to execute scripts

# Open Powershell as Admin and Execute the following to allow Powershell Scripts execution
# Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
# Set-ExecutionPolicy Unrestricted

The PowerShell Script

The PowerShell script is simple as it shows below. It requires two parameters:

1. The QlikView QMC Service URL: usually in the form http://myqlikurl:4799/QMS/Service
2. The QlikView Task ID: this is a Task ID GUID number. You can get the Task ID from QlikView QMC Task Log - probably there are other ways to get this GUID too.

param (
    [Parameter(Mandatory=$true)]
    [string]$QlikViewQMCServiceUrl,
    [Parameter(Mandatory=$true)]
    [string]$TaskID
)

$service = New-WebServiceProxy -Uri $QlikViewQMCServiceUrl -Namespace QlikViewServer -UseDefaultCredential 
$serviceKey = $service.GetTimeLimitedServiceKey()

$hdrs = @{}
$hdrs.Add("SOAPACTION","http://ws.qliktech.com/QMS/12/2/IQMS2/RunTask")
$hdrs.Add("Content-Type", "text/xml;charset=utf-8")
$hdrs.Add('X-Service-Key',$serviceKey)

$body = @{}
$body = '<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
<s:Body>
<RunTask xmlns="http://ws.qliktech.com/QMS/12/2/">
<taskID>' + $TaskID + '</taskID>
</RunTask>
</s:Body>
</s:Envelope>'

$res = Invoke-WebRequest -Uri $QlikViewQMCServiceUrl -Method Post -Body $body -UseDefaultCredential -Headers $hdrs

Running the PowerShell Script

We can Run the PowerShell Script in multiple ways:

• CMD
• PowerShell
• Batch Files
• Qlik Sense Task
• Qlik Sense Load Script
• SQL Server Stored Procedures
• Any other platform that supports PowerShell scripts

For now, we'll run it through Qlik Sense Load Script:

EXECUTE powershell.exe -ExecutionPolicy Bypass -File "$(vTempPowerShellScriptFile)" -QlikViewQMCServiceUrl "$(vTempQlikViewQMCServiceUrl)" -TaskID "$(vRunningTask)";

To call the EXECUTE statement in the Load Script you must enable the Legacy Mode in your Qlik Sense Server.

• vTempPowerShellScriptFile is the full path of the PS1 PowerShell Script file
• vTempQlikViewQMCServiceUrl is the QlikView QMC Service Url
• vRunningTask is the QlikView Task ID

That is it! Now from Qlik Sense Server we can call QlikView Tasks with minimum changes in our server environments.

Enhancing the PowerShell Script

The PowerShell Script in my example contains only the core of its functionality. I strongly recommend including log messages and error handling through try/catch/finally blocks.

What about Qlik Cloud?

I haven't tested this but here is my theory:

1. Have a SQL Server on-prem with access the QlikView Server
2. Create a Store Procedure with the same parameters of the PowerShell Script. The Stored Procedure will execute the PowerShell Script.
3. Install and configure Qlik Data Gateway on a server with access to the SQL Server Database
4. On Qlik Cloud setup a SQL Server connection based on the Qlik Data Gateway
5. From Qlik Cloud, create a Qlik Sense Application that calls the Stored Procedure from the Load Script - For more info: Solved: Qlik Data Gateway with SQL Stored Procedures - Qlik Community - 2001425

That should do the magic. Please let me know if you have tried this and if it has worked.

Monitoring of Tasks that reload Apps in Qlik Sense.
One or more tasks are scheduled on the Qlik server that automatically load the Apps,
The goal is to be able to query the status of a task with the help of REST API technology and integrate it with the PRTG monitoring system.

Step 1 -> Creation of a dedicated Virtual Proxy in Qlik QMC.

The documentation to be able to proceed is available from the following link:

https://community.qlik.com/t5/Official-Support-Articles/Qlik-Sense-How-to-set-up-JWT-authentication/...

Step 2 -> API Query Mode and Test.

Once the JWT virtual proxy has been configured and the validity of the Token has been verified as per the official guide, it is possible to proceed with the desired query.

NB. In this case we validated the token using a Service user who also runs all the dedicated services including the Proxy Service.

In this case we will monitor the correct reload of the tasks on the QLIK server, the Tasks are scheduled on the server and allow the App data to be reloaded.
When one of these tasks fails via API call, it is possible to have a json result with the related details inside.
Below is an example of an API call:

This is an example of a task we want to monitor:

A quick method to test if the call was successful is from the browser using the Mode Header extension for google chrome described in step 1.

https://chrome.google.com/webstore/detail/modheader-modify-http-hea/idgpnmonknjnojddfkpgkljpfnnfcklj

So for the call to be successful you need to pass the following parameters:
Where Header name: Authorization and Header value: Bearer followed by the previously generated and tested Token and finally the Xrfkey key.

This will be the result in Json format returned by the browser if the call is successful:
Specifically in PRTG what we are going to monitor is:

1. The name of the Task in this case "test"
   The status in this case"status":7 = Success
2. Task name "name": "Reload task of TEST TASK FAIL"
3. Start and end time date:

        "startTime": "2022-05-04T07:46:34.100Z"
        "stopTime": "2022-05-04T07:46:37.636Z"

3. Other information that we may integrate and otherwise see in PRTG.

NB. A table with Qlik Sense reload task status codes and descriptions is available from the following link

https://help.qlik.com/en-US/alerting/July2023/Content/QlikAlerting/system-alerts.htm

This is an example of the string JSON with ok API call.

Step 3 -> Task monitoring from PRTG.

Type of sensor used in PRTG.

How to create a sensor.

The path on the PRTG server where the template is to be uploaded is as follows:

C:\Program Files (x86)\PRTG Network Monitor\Custom Sensors\rest

In the following path, however, it is necessary to define a Lookups in order to allow the sensor to interpret the various states of the Qlik Tasks listed in Step 2.

C:\Program Files (x86)\PRTG Network Monitor\lookups\custom

Result JSON query Task from Browser a part of this information will be used for the sensor in PRTG each task will correspond to a specific sensor.

The REST Custom Sensor was used in PRTG.
The REST Custom sensor queries a Representational State Transfer (REST) application programming interface (API) endpoint and maps the JavaScript Object Notation (JSON) or Extensible Markup Language (XML) result to the sensor values the mapping rule must be available as a REST configuration file in JSON template format (*.template) according to the PRTG API definition for custom sensors.

                              Two files have been created on the PRTG server.

                               Final integration flow monitoring Task PRTG -> QLIK.

How the DoD makes decisions is changing. Historical transaction reporting and static batch data analyses are giving way to predictive data science, streaming analytics, machine learning (ML), and artificial intelligence (AI). The DoD must embrace these new paradigms for more informed, real-time decisions to impact business, operations, and mission performance.

This whitepaper will address how Qlik can enable the DoD to achieve it's mission.