Qlik Sense

---
name: qlik-sense
description: "Expert coverage of Qlik Sense across all deployment models (Cloud, Enterprise on Windows, Enterprise on Kubernetes). Provides deep expertise in the QIX Associative Engine, data modeling (star schema, synthetic keys, circular references), set analysis, load scripting, app design (DAR pattern), Insight Advisor, Qlik Answers, Qlik Predict, embedding (qlik-embed, nebula.js, enigma.js), section access, governance, and performance optimization. WHEN: \"Qlik\", \"Qlik Sense\", \"QIX Engine\", \"Qlik Cloud\", \"Qlik Associative Engine\", \"set analysis\", \"QVD\", \"Qlik load script\", \"Qlik NPrinting\", \"Qlik Automate\", \"Qlik Reporting Service\", \"Insight Advisor\", \"Qlik Answers\", \"Qlik Predict\", \"qlik-embed\", \"nebula.js\", \"enigma.js\", \"master items\", \"section access\", \"Qlik Talend\", \".qvf\", \"synthetic key\", \"associative model\"."
license: MIT
---

# Qlik Sense

This skill covers Qlik Sense across all supported deployment models -- Qlik Cloud (SaaS), Qlik Sense Enterprise on Windows (client-managed), and Qlik Sense Enterprise on Kubernetes:

- QIX Associative Engine internals (symbol tables, data tables, state space, in-memory columnar storage)
- Data modeling: star schemas, synthetic key resolution, circular reference elimination, link tables
- Load scripting: LOAD/SQL SELECT, QVD optimization, incremental loading, preceding loads, ApplyMap()
- Set analysis: identifiers, operators, modifiers, element functions (P/E), alternate states
- App design: DAR pattern (Dashboard/Analysis/Reporting), master items, bookmarks, stories
- Qlik Cloud architecture (Kubernetes microservices, MongoDB metadata, NGINX ingress, auto-scaling)
- Enterprise on Windows (Engine Service, Repository, Proxy, Scheduler, shared persistence, RIM nodes)
- AI features: Insight Advisor (search, chat, associative insights), Qlik Answers (agentic AI), Qlik Predict (AutoML)
- Embedding: qlik-embed web components, nebula.js, enigma.js, Capability APIs, iframe/Single Integration API
- Governance: spaces (personal, shared, managed, data), section access (RLS), security rules, content lifecycle
- Performance: expression optimization, calculation conditions, ODAG, application chaining, QVD segmentation

When a question relates to Qlik Cloud vs. client-managed differences, clarify the deployment model. When the deployment model is unknown, provide general guidance and note where behavior differs.

## When to Use This Agent

**Use this agent when:**
- Question involves Qlik Sense data modeling, set analysis, or load scripting
- User needs help with the associative engine behavior (green/white/gray selections)
- Designing app structure, master items, or visualization layout
- Troubleshooting performance (slow apps, memory issues, reload failures)
- Configuring Qlik Cloud (spaces, identity providers, Qlik Automate workflows)
- Administering Qlik Sense Enterprise on Windows (QMC, reload tasks, node topology)
- Embedding Qlik content in external applications
- Setting up section access or security rules
- Working with Qlik Answers, Insight Advisor, or Qlik Predict

**Route back to parent when:**
- Question is about choosing between Qlik and another BI tool (see the `overview` skill in this plugin)
- Question is about general dimensional modeling or chart design theory (see the `overview` skill in this plugin)
- Question involves a different BI technology entirely

## How to Approach Tasks

1. **Classify** the request:
   - **Data modeling** -- Load `references/architecture.md` for star schema design, synthetic keys, QVD strategy, load scripting
   - **Set analysis / expressions** -- Load `references/best-practices.md` for set analysis patterns, expression optimization, master item design
   - **App design / visualization** -- Load `references/best-practices.md` for DAR pattern, object limits, color, responsive layout
   - **Performance tuning** -- Load `references/diagnostics.md` for slow app diagnosis, memory issues, expression profiling, reload optimization
   - **Administration / troubleshooting** -- Load `references/diagnostics.md` for reload failures, connectivity, engine health, monitoring checklists
   - **Embedding** -- Load `references/architecture.md` for qlik-embed, nebula.js, enigma.js, authentication methods
   - **AI features** -- Load `references/architecture.md` for Insight Advisor, Qlik Answers, Qlik Predict
   - **Governance / security** -- Load `references/best-practices.md` for spaces, section access, naming conventions, development lifecycle

2. **Identify deployment model** -- Determine whether the user runs Qlik Cloud (SaaS) or client-managed (Enterprise on Windows/Kubernetes). Features like Qlik Answers, Qlik Predict, and managed spaces are Cloud-only. Security rules and QMC are client-managed only. Streams exist only on client-managed; Cloud uses spaces.

3. **Load context** -- Read the relevant reference file for deep technical detail.

4. **Analyze** -- Apply Qlik-specific reasoning. Consider app size (disk and RAM footprint), data model complexity (synthetic keys, circular references), deployment model, license tier, and user skill level.

5. **Recommend** -- Provide actionable guidance with load script examples, set analysis expressions, configuration steps, or design patterns.

6. **Verify** -- Suggest validation steps (Data Model Viewer for model health, Performance Profiler for expression timing, Operations Monitor for system metrics).

## Product Suite Overview

### Core Platform

**Qlik Sense** -- Enterprise analytics platform built on the Qlik Associative Engine (QIX Engine). Differentiates from SQL-based BI tools through dynamic in-memory data association. Every data point is associated with every other data point; selections instantly reveal related (white), selected (green), and excluded (gray) values across the entire data model.

**Qlik Cloud** -- Fully managed SaaS deployment on AWS. Container-based microservices on Kubernetes with MongoDB metadata, NGINX ingress, horizontal auto-scaling, and zero-downtime deployments. Continuous updates (~every 5 days). Performance-tested for 10,000+ users/hour.

**Qlik Sense Enterprise on Windows** -- Self-managed on-premises deployment with shared persistence architecture. Components: Engine Service, Repository Service (PostgreSQL), Proxy Service, Scheduler Service, Printing Service. Multi-node via Central + RIM nodes.

**Qlik Sense Enterprise on Kubernetes** -- Containerized private cloud deployment using the same microservices architecture as Qlik Cloud within the customer's Kubernetes cluster.

### AI and Augmented Analytics

**Insight Advisor** -- AI-powered analytics assistant with search-based visual discovery (NLP to auto-generated visualizations), conversational analytics (chat with follow-ups), and associative insights (automated pattern detection). Learns from user behavior and a configurable business logic layer.

**Qlik Answers** -- Agentic AI assistant (GA 2025-2026) combining structured analytics and unstructured data (documents, knowledge bases) with LLMs. Discovery Agent (GA March 2026) enables autonomous data exploration. Supports MCP integration for third-party AI assistants.

**Qlik Predict** -- Automated ML (formerly AutoML). No-code classification and regression model building with automated feature engineering, model selection, hyperparameter tuning. Prediction results flow into Qlik visualizations and set analysis expressions.

### Data Integration

**Qlik Talend Cloud** -- Unified data integration and quality platform providing ELT/ETL pipelines, change data capture (CDC), data quality profiling/cleansing, and a data catalog. Supports Open Lakehouse (managed Apache Iceberg, announced 2025).

### Automation and Reporting

**Qlik Automate** -- No-code workflow automation with 400+ connectors (Slack, Teams, Jira, Salesforce, email). Trigger-based flows, data-driven actions, template library.

**Qlik Reporting Service** -- Pixel-perfect PDF/PowerPoint report generation with scheduled distribution and burst reporting. Cloud-native replacement for NPrinting.

**Qlik NPrinting** -- Client-managed report generation for on-premises deployments (Word, Excel, PowerPoint, PDF, HTML).

### Licensing

| Deployment | License Model |
|---|---|
| Qlik Cloud | Capacity-based (consumption units) or per-user |
| Enterprise on Windows | Token-based or per-user (Professional, Analyzer) |
| OEM/Embedded | Per-user or capacity-based, white-label support |

## QIX Associative Engine

The QIX (Qlik Indexing) Engine is the computational core. It dynamically indexes all data associations in memory using columnar storage with symbol/data table compression.

### How It Works

1. Data is loaded via a script (LOAD/SQL SELECT statements) into the engine's in-memory model
2. Each unique value is stored once in a **symbol table**; rows reference symbols via pointers (**data tables**)
3. The **state space** tracks selection states across all fields
4. When a user selects a value, the engine instantly calculates associated (white), selected (green), and excluded (gray) values across the entire model
5. The **calculation engine** evaluates expressions, aggregations, and set analysis in real time

### Key Characteristics

- 64-bit, multi-threaded, exploits all available CPU cores
- No pre-aggregation required -- all calculations at query time
- Columnar compression ratios often 10:1 or better
- Automatic data association based on matching field names
- Built-in expression result caching

## Data Model

### Star Schema Target

The optimal model for the QIX engine is a star schema: central fact table(s) with foreign keys to surrounding dimension tables. This minimizes synthetic keys, optimizes memory, and provides the best calculation performance.

### Synthetic Keys

When two tables share multiple fields, Qlik automatically creates synthetic key tables (`$Syn`). These are almost always unintended and degrade performance.

**Resolution strategies:**
- Concatenate composite keys: `Year & '-' & Month as YearMonth`
- Rename non-key fields to make them unique across tables
- Use link tables for complex relationships
- Drop unneeded fields from one table

### Circular References

Circular references create ambiguity in the associative model. The engine breaks them with loosely coupled tables (dotted lines in the Data Model Viewer), degrading calculation accuracy and performance. Restructure the model or use a link table to resolve.

## Load Scripting

### Key Constructs

```
// Standard data load
SQL SELECT CustomerID, Name, Region FROM Customers;

// QVD optimized load (no transformations = 10-100x faster)
LOAD * FROM [lib://DataFiles/Customers.qvd] (qvd);

// Preceding load (stacked transformation in one pass)
LOAD
  *,
  Year(OrderDate) as OrderYear,
  Month(OrderDate) as OrderMonth
;
SQL SELECT * FROM Orders;

// Mapping load + ApplyMap for lookups
RegionMap:
MAPPING LOAD RegionID, RegionName FROM Regions;

LOAD
  *,
  ApplyMap('RegionMap', RegionID, 'Unknown') as RegionName
FROM Orders;

// Incremental load pattern
QVD:
LOAD * FROM [lib://QVD/Orders.qvd] (qvd)
WHERE NOT EXISTS(OrderID);

SQL SELECT * FROM Orders WHERE ModifiedDate >= '$(vLastLoad)';

CONCATENATE(QVD)
LOAD * RESIDENT NewOrders;

STORE QVD INTO [lib://QVD/Orders.qvd] (qvd);
```

## Set Analysis

Set analysis defines the aggregation scope independently of user selections. It is conceptually a WHERE clause operating within the associative model.

### Syntax

```
Aggregation({SetExpression} Expression)
```

| Element | Symbol | Purpose |
|---|---|---|
| Identifier | `$` (current selections), `1` (all data), `BookmarkId` | Base record set |
| Operators | `+` (union), `*` (intersection), `-` (exclusion) | Combine sets |
| Modifiers | `<Field={Value}>` | Filter the set |

### Common Patterns

```
// Ignore current Year selection
Sum({$<Year=>} Sales)

// Force specific year
Sum({$<Year={2024}>} Sales)

// All data, ignore all selections
Sum({1} Sales)

// Year-over-year comparison
Sum({$<Year={$(=Max(Year)-1)}>} Sales)

// Element function: customers who purchased in 2024
Sum({$<Customer=P({1<Year={2024}>} Customer)>} Sales)

// Search expression: products with sales > 1000
Sum({$<Product={"=Sum(Sales)>1000"}>} Sales)
```

### Set Analysis vs If()

Set analysis is evaluated before aggregation, making it significantly faster than equivalent `If()` conditions inside aggregations. Always prefer set analysis for conditional aggregation.

## Embedding

### Embedding Frameworks

| Framework | Use Case | Status |
|---|---|---|
| **qlik-embed** | Modern web apps (React, Svelte, HTML); handles auth and rendering | Primary recommended |
| **nebula.js** | Custom visualization development and integration | Active |
| **iframe / Single Integration API** | Quick embedding with minimal code | Active |
| **Capability APIs** | Full programmatic control of embedded objects | Legacy |
| **enigma.js** | Low-level WebSocket communication with QIX engine | Active (advanced) |

### Authentication for Embedding

- **Qlik Cloud**: OAuth 2.0, JWT, API keys via qlik-embed configuration
- **Client-managed**: Virtual proxy with SAML, OIDC, JWT, or header-based authentication
- **OEM/white-label**: Multi-tenant with per-user or capacity licensing, custom branding, allowed origins

## Governance

### Spaces (Qlik Cloud)

| Space Type | Purpose |
|---|---|
| Personal | Individual development workspace |
| Shared | Team collaboration with role-based access |
| Managed | Governed publishing with separated development and consumption |
| Data | Centralized data assets and connections |

### Section Access

Row-level and field-level data security defined within the load script. Controls which users see which data subsets from a single app.

```
SECTION ACCESS;
LOAD * INLINE [
  ACCESS, USERID, REDUCTION
  USER, DOMAIN\user1, Region1
  USER, DOMAIN\user2, Region2
  ADMIN, DOMAIN\admin1, *
];

SECTION APPLICATION;
```

## Anti-Patterns

1. **"Unresolved synthetic keys."** Synthetic keys (`$Syn` tables in the Data Model Viewer) indicate unintended multi-field joins. They force the engine to maintain additional cross-reference tables, degrading performance and memory usage. Always create explicit composite keys or rename non-key shared fields.

2. **"Circular references in the data model."** Circular references create loosely coupled tables (dotted lines in the model viewer). The engine's association logic becomes ambiguous, producing incorrect or inconsistent calculations. Restructure with link tables or remove redundant join paths.

3. **"If() instead of set analysis."** Using `If(Year=2024, Sales)` inside an aggregation forces row-by-row evaluation. The equivalent `Sum({$<Year={2024}>} Sales)` applies the filter before aggregation. Set analysis is always faster for conditional measures.

4. **"Loading all data when subsets suffice."** Loading full transactional history when only the last 2 years is needed wastes memory and slows reloads. Filter at the source (SQL WHERE clause) or use QVD segmentation by time period.

5. **"Too many objects per sheet."** Each visualization recalculates on every selection change. Sheets with 15+ objects become sluggish. Keep dashboard sheets to 5-8 objects; use containers and tabs for additional content.

6. **"Nested Aggr() functions."** `Aggr()` forces row-level recalculation within an aggregation. Nesting them compounds the cost. Simplify by pre-calculating in the load script or restructuring the expression.

7. **"Skipping QVD intermediate layer."** Loading directly from source databases on every reload is slow and stresses source systems. Structure pipelines as Source -> QVD layer -> Application load. QVD reads are 10-100x faster than database queries.

8. **"No calculation conditions on heavy objects."** Without a calculation condition, every chart calculates against the full dataset on first load. Add conditions like "Select a Region to display data" on expensive objects to prevent unnecessary computation.

## Reference Files

Load these for deep technical detail:

- `references/architecture.md` -- QIX engine internals, deployment models (Cloud/Windows/Kubernetes), app model, load scripting, set analysis syntax, embedding frameworks (qlik-embed, nebula.js, enigma.js), Qlik Cloud services
- `references/best-practices.md` -- Data modeling patterns (star schema, synthetic key resolution), set analysis recipes, app design (DAR pattern, master items), performance optimization, expression tuning, governance (spaces, section access, naming), deployment recommendations
- `references/diagnostics.md` -- Slow app diagnosis (Data Model Viewer, Performance Profiler), memory issues, reload failures, engine performance (CPU/RAM/disk), connectivity troubleshooting, monitoring checklists (daily/weekly/monthly)