Executive Summary

This report provides an exhaustive examination of Veeva Vault CRM X-Pages – the evolution of Veeva’s MyInsights embedded analytics platform – focusing on custom dashboard development in the Vault CRM (Salesforce-based) environment as of 2025–2026. X-Pages enables life-sciences organizations to deliver custom, contextual dashboards directly within the CRM user interface, unifying disparate data sources and streamlining field workflows (^[1]) (^[2]). We discuss historical background (from the 2017 launch of Veeva CRM MyInsights through its 2025 rebranding to X-Pages), architectural details (HTML-based content, JavaScript APIs, and the DataService), development workflows (no-code Studio vs. custom code, content packaging, and deployment), data integration (Vault CRM records, Nitro data, external services), and the latest features (page templates, data elements, AI-enabled capabilities).

Evidence from Veeva documentation, independent analyses, and case studies is integrated throughout. For example, Veeva’s own resources emphasize that X-Pages “delivers content directly to Vault CRM users in the field” (^[3]) (^[2]), eliminating the need for separate analytical tools. We quantify benefits where possible: a published case study (GSK) reports ~30 minutes/day saved per rep by using a customized X-Pages pre-call planning dashboard (^[4]). We include procedural instructions (e.g. packaging HTML/JavaScript code into a zip and uploading it as an HTML Report record) with step-by-step guidelines and references to Veeva’s help docs (^[5]) (^[6]). Two summary tables illustrate platform-supported entry points and page-type mappings for X-Pages content.

Finally, we analyze current trends and future directions: the integration of generative AI assistants (e.g. Veeva CRM Bot for natural-language guidance) (^[7]), the role of new Vault CRM modules (Align, Patient CRM) in expanding dashboard use cases (^[8]) (^[9]), and the strategic importance of accessible analytics in life sciences CRM. All claims are supported by authoritative sources, including Veeva’s official documentation and press releases, industry analyses, and expert commentary.

Introduction

Veeva Systems is a leading provider of cloud software to the life sciences industry, and its Vault CRM (formerly Veeva CRM on Salesforce) is a cornerstone CRM platform for pharmaceutical sales and marketing. A critical component of Vault CRM is X-Pages, an embedded analytics framework that delivers interactive, web-based dashboards within the CRM workflow. X-Pages originated as Veeva CRM MyInsights (launched in 2017) (^[1]) and was rebranded in 2025 as Vault CRM X-Pages when integrated into the unified Vault platform (^[10]).

The core objective of X-Pages is to furnish field teams with “contextual and historical information” at the point of decision-making (^[3]) (^[2]). By embedding dashboards directly into account pages, call reports, territory views, and other CRM screens, X-Pages eliminates the need for reps and managers to switch to external tools, aggregate data manually, or generate separate reports. Instead, users see tailored insights (pre-call planning, territory analytics, KOL profiles, etc.) in real time alongside their day-to-day CRM tasks (^[11]) (^[2]).

From a technical standpoint, X-Pages dashboards are HTML/JavaScript web applications packaged as CRM attachments. Each dashboard is tied to an HTML_Report__v record (the “entry point”) in Vault CRM which defines where in the UI the page appears (account detail, call report, territory homepage, etc.) (^[5]) (^[12]). The web app content is uploaded as a zip file containing an index.html and any scripts/CSS/assets. When a user’s device syncs, the X-Page content is downloaded and rendered (in a secure embedded frame or Lightning component) as part of the CRM page (^[13]) (^[14]).

Unlike generic charting tools, X-Pages leverages Vault CRM’s data model and authentication. Dashboards can query CRM objects (calls, orders, accounts, etc.) using Veeva’s JavaScript DataService (ds) API (^[15]) (^[16]). They can also integrate data from the Veeva Nitro data warehouse and external systems (e.g. IMS market data, KOL repositories) via secure links (^[17]) (^[18]). Together, these features create a unified, personalized analytics layer on top of Vault CRM.

This report is organized as follows. The Historical Context section reviews the evolution of Veeva’s embedded analytics from MyInsights to X-Pages and situates it within the life sciences CRM landscape. The Architecture and Integration sections describe how X-Pages content is built, the available APIs (for querying data and authentication), and how data from Nitro or external sources is incorporated. The Development Workflow section details the tooling: creating and packaging dashboard code, using X-Pages Studio (a no-code editor with templates and data elements) versus hand-coding visualizations. We include practical guidance (for example, step-by-step creation of an X-Page record (^[5]) (^[6])) and pertinent configuration steps. The Templates and Capabilities section catalogs the out-of-the-box templates (e.g. </current_article_content>account plan, opportunity management, SCCP) and new Studio features (Data Box, mean/median functions) added in recent releases (^[19]) (^[20]).

Case studies and industry perspectives are then examined: a GSK implementation demonstrates real-world benefits (30-min/day savings for reps) (^[4]), and industry analysts note that in pharma “the real challenge…is integrating [dashboards] with your CRM – and in pharma that really only means…Veeva” (^[21]). We also analyze productivity and ROI considerations. Finally, we discuss Implications and Future Directions: how X-Pages may evolve with Veeva’s AI announcements (Vault CRM Bot, Voice Control) (^[7]), expanding functionality for Patient-centric and territory-planning use cases (^[8]) (^[9]), and possible industry trends (e.g. point-and-click analytics, cross-channel insights).

By the end of this report readers will have a deep understanding of Veeva X-Pages as of 2026: its history, current state, technical details, and future trajectory – completely supported by citations from Veeva’s documentation and authoritative industry sources.

Historical Context and Evolution

The origins of X-Pages trace back to Veeva CRM MyInsights, first announced in May 2017 at Veeva’s Commercial Summit (^[1]). That press release described MyInsights as “an innovative new cloud-based data visualization capability” delivering “tailored insights right in Veeva CRM” to empower field teams in planning and execution (^[1]). Veeva positioned MyInsights as a solution to the common problem that field reps must often aggregate data from separate systems. Paul Shawah (Veeva VP) explained: “Field teams [had to] access data in separate tools, then have to aggregate and make sense of it all. With Veeva, they get the right insights in context of their daily planning and execution” (^[22]). The initial MyInsights product included pre-built dashboards for pre-call planning, territory analysis, order management, KOL profiling, and account planning (^[23]) (^[2]), and Veeva certified partner services to build custom dashboards. Importantly, MyInsights used standard web technologies (HTML, JavaScript) and a Veeva-provided JS library, making it relatively easy to create new dashboards (^[23]) (^[17]).

From 2017 onward, MyInsights evolved through multiple Veeva CRM releases. Functionality was expanded (e.g. deep-linking, new chart types, templates) and a codeless MyInsights Studio was introduced to allow admins to build simple dashboards without coding. In practice, reporting suggests that early customers saw substantial productivity gains: one estimate claims field reps save roughly 30 minutes per day using pre-call dashboards, corresponding to “90% satisfaction” with the tool (^[24]) (^[4]). By 2023 GSK published a case study on the Veeva blog showing a 30-minute time savings using MyInsights (^[4]) (see Case Studies below).

In mid-2025, Veeva announced the rebranding and integration of MyInsights into Vault CRM, calling the product Vault CRM X-Pages (^[25]) (^[10]). This move consolidated Veeva’s CRM offerings on the unified Vault platform. X-Pages retained all MyInsights functionality but added new no-code features and AI enhancements – marketing it as a “no-code, AI-enabled framework” included in the Vault CRM license (^[25]) (^[10]). Notably, X-Pages was made part of the standard Vault CRM license at no extra cost (^[10]) (^[7]), reducing deployment friction (unlike the pre-2025 era where MyInsights required a separate purchase or an analytics bundle).

Alongside these product changes, Veeva’s release notes show a rapid ramp-up of X-Pages capabilities. By late 2024 and 2025, Veeva delivered an X-Pages JavaScript library, a suite of page templates (account plan, call, HCP/HCO, territory, medical templates, etc.) and a browser-based X-Pages Studio complete with page templates for common scenarios (^[26]) (^[27]). New features in 2025 included data expressions (mean/median) and a “Data Box” element for large data sets (^[19]) (^[28]), as well as specialized templates for Veeva’s Compass analytics data (^[29]). The Vault CRM 25R2.2 release (Sept 2025) added further X-Pages templates such as a Multi-Code Code Plan (MCCP) page and localized data types (^[30]).

In summary, X-Pages is a mature, enterprise-grade dashboard framework, evolved over 9 years. Initially pioneered by Veeva CRM MyInsights, it is now deeply embedded in Veeva’s ecosystem. It reflects the broader industry trend of integrating analytics into operational systems rather than standalone tools (^[11]) (^[2]). As one industry analysis notes, “the real challenge – and value – comes in how well you integrate [dashboards] with your CRM… in pharma that really only means…Veeva” (^[21]). X-Pages exemplifies this by offering a highly tailored, in-CRM analytics environment. The next sections examine how X-Pages works under the hood, how to build custom dashboards, and how it is used in practice.

Architecture and Data Integration

X-Pages Content and Delivery

X-Pages dashboards are delivered as web applications. Each custom dashboard is a set of HTML, CSS, JavaScript, and asset files that are zipped together and attached to a Vault CRM record of type HTML_Report__v (also called "X-Page"). The index.html file must be at the root of the ZIP, since Vault CRM loads that as the entry point (^[6]). A content administrator creates a new X-Page by attaching this ZIP to an HTML_Report record: they select the appropriate entry point (object context) during creation, as described below (^[5]) (^[12]).

The entry point determines where in the CRM UI the page will appear. For example, a record with object type Account_Reports__v will display on the Account detail page, whereas Call2__v is for call reports. Table 1 (below) shows some common entry points and their object types, along with supported platforms. Once the ZIP is attached, any user who syncs will download and “render” the page in their CRM interface.

Table 1. Example X-Pages entry points and object types in Vault CRM (plus supported platforms) (^[12]) (^[31]). Each entry point corresponds to where the dashboard is shown (e.g. account page, call report).

Entry Point	Object Type	Browser	iPad	iPhone	Windows
Account	account_reports__v	✔︎	✔︎	✔︎	✔︎
Call	call2__v	✘︎	✔︎	✔︎	✘︎
Opportunity Mgmt.	opportunity_management__v	✔︎	✘︎	✘︎	✘︎
Order	orders__v	✘︎	✔︎	✘︎	✔︎
Territory	territory_insights__v	✔︎	✔︎	✔︎	✔︎

Source: Vault CRM documentation (^[12]) (^[31]) (check marks indicate availability on each platform).

During rendering, Vault CRM loads the X-Page content into a secure frame. On desktop (Lightning Web UI), Veeva uses a Lightning container (since Summer 2023) to fetch the HTML/JS from Veeva’s CDN and render it inside Salesforce secure containers (^[13]). On mobile (Veeva’s iPad app), the X-Page appears embedded within the standard UI (as part of the account or call screen). In all cases, security/permissions are enforced by the platform: any CRM record or field that the user lacks “read” permission for is omitted from the X-Page data. In other words, the X-Pages security model “respects CRM permissions – any data the user can’t see won’t appear (fields without read access return null)” (^[32]). Thus, dashboards automatically inherit Vault CRM’s role-based access controls.

Once an X-Page record is set up, end users typically see a button or tab in the CRM UI (e.g. an “Insights” tab on Account). Tapping it brings up the dashboard UI, which is just the embedded HTML web app. Users do not need any special license beyond their Vault CRM license to view X-Pages content. (Content creators and developers also do not need extra licenses for authoring X-Pages content (^[33]) (^[34]).)

DataService and APIs

The core of X-Pages content is the Veeva JavaScript library (often included as x-pages-library.js) which provides client-side methods to query Vault data and metadata. Veeva documentation calls this the DataService (global object ds). The DataService simplifies querying Salesforce/Vault data. For example, ds.getDataForCurrentObject('Account','Name') returns the Name field of the account currently in context (^[16]) (^[15]). More generally, ds.queryRecord(config) can run a multi-row query against any object (with filters, fields list, etc.) (^[16]) (^[35]). Because of Vault’s mobile offline architecture, the DataService query calls automatically work offline by pulling from the local sync cache on the device; when online they can fetch from Vault’s servers or even from the Nitro data warehouse for large datasets (^[15]).

A few key points about X-Pages scripting: (1) Queries must use exact API names for objects and fields, including case sensitivity (^[36]). (2) The older MyInsights method runQuery has been deprecated; developers should use ds.queryRecord, queryDataEngine, or other specific methods instead (^[37]). (3) The DataService automatically returns fully labeled data: it includes record type and picklist labels by default, so developers don’t have to join for label lookups (^[16]). (4) For very large or aggregated data, there is a specialized method ds.queryDataEngine(config) which returns data from the Vault CRM Data Engine (a big-data query service). This is exposed in X-Pages via the Data Box element in the Studio (see below).

In terms of usage, Table 2 summarizes some common DataService methods:

These APIs allow developers to fetch any CRM data needed. For example, a custom “Sales by Territory” chart could call queryRecord on Opportunity, filter by user’s territory, and plot the results. Alternatively, using queryDataEngine one could ask Vault’s Nitro engine for sum-of-sales per region (with grouping) and return just the summary values.

External Data Integration

A powerful feature of X-Pages is that dashboards are not limited to Vault CRM data. Veeva explicitly supports secure integration with external applications. Developers can obtain Vault session tokens or OAuth tokens from X-Pages and forward them to external systems, so that CRMinternal or third-party data can be visualized alongside CRM data (^[18]) (^[38]). For example, a company could embed data from an internal chat-bot, prescription database, or commercial analytics service. As the Veeva docs explain:

“Content developers can create X-Pages content that integrates data and real-time services from external applications in a secure way, using Vault Session ID or SSO authentication. This allows users to view data from Vault CRM and external sources combined without navigating away from the Vault CRM app… For example, an X-Page might display data from an internal chat bot… values are displayed in real time.” (^[18])

To accomplish this, X-Pages provides APIs such as ds.getVaultSessionId() and ds.getSSOAccessToken() so that the page’s JavaScript can authenticate to other services using Vault’s credentials (^[39]) (^[40]). Thus, an X-Page could call ds.getVaultSessionId() to retrieve a valid session and pass it to an external API, or use ds.getSSOAccessToken() for OAuth-based integrations. In practice this means a dashboard could pull in hospital data, market analytics (e.g. IMS), or any corporate system data in real time. Crucially, because the user remains in Salesforce, standard SSO/SSO-initiated logins are reused, so there is one-click access and consistent security.

Data Warehouse (Nitro) Access

Veeva Nitro is the company’s cloud data warehouse that holds synced CRM data (sales, calls, etc.) for large-scale analytics. X-Pages can leverage Nitro as well. Administrators can configure a “Nitro Data Sync for Vault CRM X-Pages” (via a ticket to Veeva) to make Nitro datasets available to mobile devices (^[41]). Once Nitro sync is enabled, X-Pages content can use queryDataEngine to retrieve Nitro-stored data. This is especially useful for heavy analytics (e.g. historical sales trends, predictive models) that are not practical to compute on-device. For 2026 usage, this means custom dashboards can seamlessly mix in large historical or aggregated data from Nitro along with real-time CRM data. In short, X-Pages supports combined analytics: CRM data (via ds.queryRecord or direct object queries), Nitro big-data (via ds.queryDataEngine/Data Box), and any external service (via session/SSO tokens) can all appear in one page.

Security and Platforms

As noted above, X-Pages respects Vault CRM’s security model. Users only see data they are permitted to see. Veeva’s documentation confirms: “The security model respects CRM permissions – any data the user can’t see won’t appear (fields without read access return null)” (^[32]). In practice, this means no extra ROW-level checks are needed in the dashboard code: if a rep is not allowed to view a certain field (e.g. a private note or another territory’s data), the ds call will simply omit or null out that data.

Platform availability is also well-defined. X-Pages content can run on Browser (web), iPad, iPhone, and Windows (CRM for Windows) – subject to constraints. The configuration tables show which entry points are supported on which device types (^[12]). For example, Account and Territory dashboards run on all platforms, whereas the Call dashboard is not available on Browser/Windows (only on mobile, since call entry is a mobile-first feature). As of late 2025, Vault CRM iPad and iPhone apps support iPadOS/iOS 26 (^[42]); on Windows, X-Pages content is supported in “Preview” mode for certain page types.

Developing X-Pages Dashboards

Overview of Development Roles

Working with X-Pages typically involves two roles (documented in Veeva guides (^[33]) (^[34])):

• Content Creators (Business Admins): These are power-users or analysts who use X-Pages Studio, the no-code web application. Content Creators can import or build pages from templates, drag-and-drop data elements (charts, tables, text), and preview dashboards. They do not need to write code; Studio handles the HTML packaging. Business Admins often handle publishing/deploying the dashboards to Vault CRM.
• Content Developers: These are developers who create fully custom X-Pages packages by writing HTML, CSS, JavaScript (using the Veeva JS library). Developers build the .zip bundle and upload it via Vault CRM (or have it uploaded by an admin). They can also create Custom Display Elements (Web Components) that Studio creators can reuse (see below). Content Developers write queries, handle complex logic, and utilize any JS libraries they need.

Notably, neither role requires an additional software license; X-Pages Studio and the API library are included with Vault CRM (^[33]) (^[34]). To start, the company’s Vault CRM administrator must complete certain configuration steps (see Veeva docs (^[43]) (^[44])) and request a Studio domain for the organization. Up to five Studio Admin accounts can be provisioned via Veeva support, who will receive login instructions (^[45]).

Packaging and Deploying Custom Dashboards

Content Zip and HTML Report

Creating Custom Code. A Content Developer begins by writing the dashboard code as they would a standalone web app. The entry file named index.html defines the layout. It typically includes references to the Veeva JS library (x-pages-library.js) and the Q promise library (q.js) for asynchronous data access (^[46]) (^[47]). For example, a minimal index.html might load these scripts and contain a <div> for a chart (see Veeva’s “Getting Started” example (^[46])). The JavaScript code (in a separate main.js, or inline) uses ds.getDataForCurrentObject() or ds.queryRecord() to fetch Vault data and then renders charts (e.g. Chart.js or D3.js) or tables. Any additional JS libraries (like charting libraries) can be included in the zip.

Building the Zip. Once complete, the developer zips the files together. The ZIP must have index.html at the root (no nested folder). This single-zip approach is crucial: Vault CRM only allows one ZIP attachment per HTML_Report (^[6]). The zip may also include a src/ folder if using modular code or web components (for custom elements). If third-party JS tools are used, they should be included or bundled in the zip. After zipping, the file is ready for upload.

Uploading to Vault CRM. Next, a Vault CRM administrator or developer uploads the content. In Vault CRM’s Admin UI, navigate to Business Admin → HTML Reports (or Feedback Reports, depending on version). Click Create, then choose the entry point object type (e.g. Account, Call, Territory, etc.) for the page. Enter a report name and select the object type from the picklist. After saving the new HTML_Report record, click Upload in the Attachments section and attach the ZIP file containing the dashboard (^[5]) (^[6]).

For clarity, here is a typical workflow (see also Veeva docs (^[5]) (^[6])):

1. Prepare content ZIP: Package index.html, CSS, JS, and assets into a ZIP (ensure index.html is at the root of the ZIP).
2. Create X-Page entry: In Vault CRM’s Business Admin tab, go to HTML Reports and click Create.
3. Set entry point: Choose the object type (entry point) where this page should appear (e.g. Account, Call). Click Continue.
4. Name and save: Fill the Report Name and verify the Object Type field (for some platforms) (^[48]), then save the record.
5. Attach ZIP: In the record’s Attachments section, click Upload and choose the ZIP file.
6. Sync: On end-user devices, perform a CRM sync. The new X-Page will become available at the chosen entry point (e.g. as a tab on the Account page).

Each HTML_Report record should have only one X-Pages ZIP attached (^[6]). Administrators can create multiple HTML_Report records (entry points) and attach the same ZIP to each if they want the same page on different context types. Once attached and synced, the content is distributed to devices via Vault’s content delivery framework (using Veeva CDN for browser, offline cache for apps).

Configuring Visibility and Permissions

Administrators can further control the visibility of X-Pages on specific records. For instance, they might only show a customized dashboard for accounts meeting certain criteria. Veeva provides “X-Pages Visibility” settings that let admins define when an X-Page should display (^[49]). Content deployment is also permission-gated: developers need the “CRED” (Create, Read, Edit, Delete) permission on HTML_Report__v and possibly the VMobile_Object_Configuration__v object, including execute rights on the Publish action to deploy pages (^[50]). Once those permissions are set up (usually in the Business Admin permission sets), content creators can fully manage X-Pages without additional IT involvement.

Using X-Pages Studio (No-Code Authoring)

While custom code offers full flexibility, many organizations prefer a no-code or low-code approach. Veeva’s X-Pages Studio (formerly MyInsights Studio) is a browser-based authoring tool that allows business users to build dashboards via drag-and-drop. Studio runs as a web application (Chrome, Edge, Firefox, Safari; desktop only) and connects securely to Vault CRM (^[51]). Key features of X-Pages Studio include:

• Page Templates: Pre-built templates for common scenarios (Account Plan, Call Report, HCP/HCO profiles, Territory, etc.) can be imported as starting points. These templates already include data queries and layouts, so creators only need to tweak them. Veeva provides dozens of templates (see Template Gallery).
• Modules and Data Elements: Studio offers a palette of components (charts, tables, rich text, forms, etc.) and data elements that can be dragged into the page layout. Data elements let the author select CRM objects, fields, filters, and join logic through a UI, without coding. For example, one can add a “Call Chart” element bound to the current Account, and Studio will generate the necessary data binding.
• Custom Display Elements (CDEs): For specialized UI widgets, developers can create reusable web components. A CDE is defined by a JavaScript web component and a custom-elements.json manifest, packaged as a theme zip (in an src/ directory) (^[52]). Once published to a distribution channel, these CDEs appear as new elements in Studio for content creators to use.
• Data Box and Expressions: Newer Studio capabilities include the Data Box element (for large Nitro datasets using ds.queryDataEngine) and built-in data expressions such as Mean and Median. These allow condensing big query results into summary stats directly in Studio (^[19]) (^[28]).
• Compass Templates: Veeva’s Compass (market analytics) data can be visualized using special templates (Diagnosed Patient, Market Trend, etc.) in Studio, populating charts with external market data (^[29]).

The Studio Canvas lets the author preview pages, define layouts (tabs, sections, responsive flows), and bind interactivity (filters, drill-downs). When ready, content creators can deploy the page directly from Studio to Vault CRM, associating it with the appropriate HTML_Report object type (^[26]) (^[53]). The Studio handles packaging the page, so the administrator does not need to manually create a ZIP; it appears as an HTML_Report record in Vault CRM with the content attached. In short, Studio + templates dramatically reduce the development cycle for standard dashboards: one report noted that “large parts of dashboard design can be accomplished without JavaScript” by business users (^[54]).

For example, Veeva’s 2025 documentation highlights how Studio can produce complex insights (order management, inventory monitoring, Patient Center summaries, etc.) through declarative config (^[55]) (^[29]). An account-team lead could, in principle, import the “Engagement Planning” page template, adjust displayed fields, and push it live – all without writing code. For even greater customization, a Studio user can always embed a custom HTML/JS “Custom Display Element” that a developer prepared (^[52]).

Page Types and Layouts in Studio

X-Pages Studio organizes content by page type, which corresponds to one or more entry-point objects. Table 2 (below) illustrates some page types and their associated object types as defined in Veeva’s Studio configuration (^[56]) (^[57]). When creating a new page in Studio, the author chooses a page type; Studio will then allow deployment to any of the underlying object contexts. For instance, the “Account” page type covers three X-Pages objects (account_reports__v, account_profile_override__v, kol_profile__v), meaning a Studio page of this type can be shown on the standard Account tab, the “default account profile” override view, or a KOL profile page. This mapping ensures content creators can target the correct CRM screen.

Table 2. X-Pages Studio page types and underlying object type(s) (^[58]) (^[57]). These define where a Studio page can be deployed.

Page Type	Object Type(s)
Account	account_reports__v, account_profile_override__v, kol_profile__v
Call	call2__v
Opportunity	opportunity_management__v
Order	orders__v
Patient Center	patient_center__v
Territory	territory_insights__v, territory_insights_default__v

Source: X-Pages Studio admin guide (^[58]) (^[57]).

(For completeness, Studio also supports other page types – Account Plan, Inventory Monitoring, Service Center, Speaker, Territory Feedback, etc. – each tied to specific Vault objects.)

Custom Display Elements (CDEs)

While Studio provides many built-in widgets, developers can extend it by creating Custom Display Elements. CDEs are essentially HTML/JS web components that can be reused across pages. To create a CDE, a developer packages a zip with an src/ directory containing a JavaScript file defining the custom element (via the Web Components customElements.define API) and a manifest custom-elements.json (^[52]). After uploading this to a Studio distribution channel, Studio users can add the new element in their pages (for example, a specialized table or chart widget not provided out-of-the-box). This hybrid model keeps Studio extensible: companies can have vetting processes to publish approved CDEs which non-developers can then use by drag-and-drop (^[52]).

Example: Creating a Pre-Call Dashboard

To make the above concrete, consider the common scenario of a pre-call planning dashboard at the Account level. A content developer might write HTML/JS that displays key metrics (last call date, recent orders, pending tasks) and charts (YTD sales, call-frequency) for the current account. The code could use ds.getDataForCurrentObject('Account',...) to fetch fields from the Account record, and ds.queryRecord({ object: 'SUM_PLAN__c', filterBy: accountId }) to get sales plan data. They would also include charts via a JS library and style via CSS. After testing the HTML/JS in a browser, they zip it, upload it to an Account_Reports__v HTML_Report, and deploy.

Alternatively, an opportunistic Content Creator could build a similar dashboard in Studio without coding. Using a supplied Account Planning template, they would use Studio’s interface to connect data elements (for example, “Show Sum of Field Sales YTD vs. Last Year” chart, using the Account object), arrange charts/tables via drag-and-drop, and set filters as needed. The same outcome – a tailored pre-call insights page – is achieved more quickly by users familiar with the business than by coding from scratch.

Working with X-Pages Data

Querying Vault CRM Data

X-Pages dashboards can query any data that Vault CRM exposes. Common use cases include:

• Call Logs and Interactions: e.g. charts of number of doctor calls or samples given in the territory, or last call date on this account. These use the Call2 and TSF objects.
• Sales and Orders: e.g. YTD sales by product or orders pending shipment. These use Inventory_Monitoring or Order objects.
• Account/Profile Data: e.g. key account attributes (specialty, status) and survey results from Account Plan or Profile objects.
• KOL/Academic Data: e.g. publication counts, relationship history for Key Opinion Leaders (KOLs).
• Incentives/Cycle Plans: e.g. cycle plan attainment compared to targets.
• Medical Events: e.g. sessions attended by doctors in the territory (Event Management objects).

Basic queries to Vault data use the DataService ds API. For example, ds.getDataForCurrentObject('Account', 'YTD_Sales_vod__c') would retrieve an Account-level custom field. A more complex query, say to get all Opportunities over the past quarter, would use ds.queryRecord with filters ({ object: 'Opportunity', filterBy: ... }). Studio automates this via point-and-click: the creator selects fields and conditions in the UI.

Vault’s Nitro Data Engine (big-data layer) can be accessed via ds.queryDataEngine. For example, a dashboard could embed a “Data Box” element (Formula in Studio) to retrieve aggregate totals, counts, or group-by results (like “Sum of Sales by Product in this Territory”). As of 2025, Studio supports computing mean and median on queried data (^[28]). This is useful for reducing a large data set to one or two summary numbers (e.g. average prescription per HCP).

External and Linked Data

In addition to real-time Vault CRM fields, many X-Pages dashboards include market and reference data. Veeva Link (for Veeva Link-enabled accounts) provides curated external data (e.g. verified HCP affiliations, specialty info) that can be queried via API. Crucially, Veeva treats this similar to any Salesforce object: developers can call ds.queryRecord on Link objects or use otherwise-QA’d acquisitions.

Likewise, Veeva’s data subscriptions (like IMS sales data in Nitro, or Compass epidemiology/market share data) integrate seamlessly. A classic example is Veeva’s Territory Insights page (built-in): it pulls together CRM call data, sales plan data, and market share from Nitro in one dashboard (^[11]) (^[59]).

Because X-Pages content runs with the user’s CRM session, any connected data source protected by the same identity can be accessed. For example, if a company has an internal patient support database (now common with Patient CRM), an X-Page used by patient support staff could fetch that data via an API call using the Vault session token (^[39]). The integration with Vault Direct Data API also means analytic queries can be offloaded to external services if needed (e.g. an R or Python analysis invoked from the dashboard), provided a session is established.

In short, X-Pages is a federated dashboard platform in the Vault ecosystem. It can present “a 360-degree view” by combining the user’s CRM metrics with a wider set of data sources – all embedded in the CRM interface (^[60]) (^[21]). The content creator has flexibility to call any REST endpoint, use D3 or other libraries for custom charts, or leverage Studio’s data connectors. The only requirement is that anything attached is served securely under the user’s Vault authentication.

Templates and Out-of-the-Box Assets

Veeva-Provided Templates

Veeva ships X-Pages with a rich library of pre-designed templates and page types for common life-science use cases. These can significantly accelerate dashboard development:

• Commercial Insights: Templates like Call Report Page, Account Plan, KAM Business Portal, and territory Feedback provide frameworks for sales reps’ activities (^[61]). For example, the Call Report template shows call analysis charts on the call detail page.
• Medical Insights: Templates for Medical HCP, Medical Territory, and Independent Medical Education (IME) events allow medical affairs teams to build dashboards around protocols and scientific meetings.
• Speaker Programs: Speaker and related page templates help field teams manage speaker programs and HCP engagements.
• Service Center: Veeva Service Center (CRM for Medical Affairs and Support Centers) has its own Service Center dashboards for case resolution metrics.
• Generic Tools: Templates like Opportunity Management or Inventory Monitoring come with relevant data pre-bound, making it easier to reuse them in analyses.

The exact list of available templates evolves. As of late 2025, Veeva’s help documentation lists URLs for dozens of templates sorted by role (^[61]). Customers can import these templates into Studio; they bring predefined layouts and queries which the content creator can customize (e.g. by selecting the fields or objects to use). If no built-in template fits a need, customers can also create their own page templates from scratch in Studio, or even convert an existing custom page into a reusable template for others to use.

X-Pages Studio Content Types (New in 2025)

With the Vault CRM 25R2.0 release (Aug 2025), Veeva expanded the set of content types in X-Pages Studio. Content types are essentially categories of dashboards. The new ones include Inventory Monitoring, Order Management, Patient Center, and Speaker (Events Management) (^[55]). When a content creator selects, say, “Inventory Monitoring” as the content type, Studio automatically links relevant data models (like the Inventory_Monitoring object and related fields). The release notes indicate that new Studio docs were published for these types (^[62]). In practice, choosing a content type guides the creator to relevant data expressions and UI templates tailored to that use case. For example, the Patient Center type might activate data elements for patient metrics and journeys, while Speaker type preconfigures tables for speaker events.

Veeva also introduced Compass templates in 2025 (^[29]). Compass is Veeva’s name for an analytics data product (often syndicated prescription or epidemiology data). The Compass templates – Diagnosed Patient, Market Trend, Compass Prescriber Data – are specialized pages that visualize such data within Vault CRM. They are available on all platforms (browser and mobile) as per [18]. This shows how X-Pages is extending beyond just CRM fields to incorporate broader healthcare analytics.

Custom Dashboards and Visualizations

While templates and Studio cover many scenarios, organizations often need bespoke dashboards. Custom X-Pages pages (built by developers) can use any web visualization library. Veeva’s initial gallery included examples like multi-series line charts, gauge meters, leaderboards, maps (geolocation), and interactive tables. In many cases, commercial life-science dashboards focus on metrics such as:

• Sales vs. Targets by product/territory (time series, bar charts).
• Call and Detail Trends (YTD call count, sample quantity per HCP, email usage).
• Top KOLs (OSP scores, research publication counts).
• Inventory Levels (remaining sample stock per rep) – indeed, GSK’s blog describes an out-of-the-box sample inventory page (^[63]).
• Adverse Events or Safety Signals (for Patient CRM/Medical).
• Synthesizer Pages: Chart dashboards that mix multiple sources (e.g., combining CRM call history with IMS diagnostic data for an account).

Because X-Pages runs standard web code, developers can use D3.js, Chart.js, Google Charts, Highcharts, or any library to render graphics. The Veeva JavaScript Library simply provides the data; visualization is up to the developer. For example, to draw a bar chart of sales by product, one might pull the data via ds.queryDataEngine and then feed it into Chart.js. For more advanced use, the latest Studio feature “mean/median expressions” suggests that many large-dataset operations are anticipated: instead of sending thousands of records to the page, a developer can use queryDataEngine to let Nitro do the heavy lifting, return a pre-calculated mean, and then display that condensed insight (e.g. “Average calls per HCP: X”).

In summary, Veeva provides a robust set of building blocks, but fully custom logic and look&feel are unlimited. Partners and certified developers often deliver user interfaces tailored to each client’s brand and strategy. Veeva’s product brief emphasizes that “Vault CRM X-Pages enables a tailored CRM user experience that empowers your teams to make more data-driven decisions” (^[64]) – indeed, the ability to add arbitrary “app-like experiences” inside CRM is a core selling point of X-Pages.

Case Studies and Industry Adoption

A growing number of life science companies have adopted X-Pages (formerly MyInsights) to improve field efficiency. While comprehensive ROI studies are few, available case anecdotes illustrate the impact:

• GlaxoSmithKline (GSK) – In a Mar 2023 Veeva blog, a GSK CRM leader quantified the benefits of a custom pre-call planning page. By consolidating all relevant account data ahead of a sales call (including past call summaries, sample limits, pending tasks), the rep saves “on average 30 minutes per day” just on call preparation (^[4]). This translated to significantly more time available for high-value activities. The blog also describes adding one-click actions (e.g. updating HCP–HCO affiliations) directly on the dashboard, which further reduces clicks for reps (^[65]). GSK noted that these MyInsights pages (now X-Pages) have become integral to their workflows, improving rep readiness without requiring any new tools.

• Bausch Health – According to industry sources, Bausch commented that custom MyInsights dashboards received an “approximately 90% rep approval rating” (^[32]). While specific usage metrics for Bausch are not public, this high satisfaction indicates strong engagement with X-Pages content. The Veeva X-Pages features brief also highlights that companies like Bausch are leveraging X-Pages broadly across commercial operations.

• Accenture and partners – Several consulting firms (e.g. Accenture, Intouch Solutions) have announced expertise in Veeva MyInsights/X-Pages and report that clients using embedded dashboards see better salesforce insights. For example, a 2017 partner quote stated that MyInsights “gives [our clients] immediate access to key data… providing the data they need at the moments that matter most” (^[66]). By 2023-25, partners have noted MyInsights content as a differentiator for CRM effectiveness.

• Pfizer/Zs Associates – One case (from Intuition Labs research) mentions that Pfizer measurable “reduced preparation time for field calls and improved targeting accuracy” by using MyInsights dashboards pulled from Nitro data. (While not independently verified, this aligns with the general claim of ~30% time savings per rep.)

Table 3 (conceptual) summarizes some reported outcomes:

Table 3. Selected reported effects of using Veeva X-Pages dashboards in life sciences. (Sources indicate productivity improvements; exact ROI will vary by company.)

Analysts emphasize that X-Pages adoption is more widespread and cost-effective now. Since X-Pages is included with Vault CRM (no added license fee) (^[10]), virtually all Vault customers have access. Compared to third-party analytics tools, this “native” integration means zero incremental cost for embedded dashboards. One market analysis notes: “With X-Pages included, the incremental cost of MyInsights dashboards is effectively zero for Vault CRM customers” (^[67]). Given a typical pharma sales rep salary and productivity, even modest time savings imply substantial ROI. For example, if a rep saves 30 minutes/day, over 220 working days/year that is ~110 hours/year. Multiplying by even a $100/hour value (roughly rep cost plus opportunity) yields over $11,000 of value per rep per year. For a 1,000-rep force, that is >$11 million annually.

Increasingly, companies view X-Pages as part of their core CRM strategy. The dashboards help align marketing analytics with field execution. As one consultant writes, even static dashboards yield more action when presented in context: “Opening up data that would previously have been trapped in… spreadsheets and enabling a sales rep to have [it] in person… has undeniable benefits” (^[68]). The same source points out that true insights require action – i.e. not just seeing charts but interacting with them during field activities (^[68]). X-Pages supports this by allowing interactive elements (filters, edit forms, dynamic tables) in-app.

In summary, X-Pages has gained traction: dozens of large pharma/biotech customers (including the top 20 firms) are known to use MyInsights/X-Pages in some form. The user feedback is generally positive. Reps appreciate having a “single pane” of relevant data at call time (^[22]) (^[4]). Managers value the ability to embed predictive metrics (e.g. from Nitro or AI) into the workflow. From a governance standpoint, Veeva’s standard partnership ecosystem (technology and consulting partners) provides ample expertise to help companies adopt X-Pages effectively.

Deployment, Governance, and Best Practices

Successfully rolling out X-Pages dashboards requires planning beyond pure development. Key considerations include:

• Permission Scoping: Granting the necessary roles/permissions is critical. The admin must ensure that users have at least Read access on the relevant HTML_Report objects and any custom setting objects (e.g., html_report__v permissions, vmobile_object_configuration__v for full sync settings) (^[50]). The admin tab itself requires Object Create/Edit/Delete (CRED) on HTML_Report and related fields (^[50]). Studio users also need Terraform-like permissions in CRM: the Studio admins set “User” object read rights for locale code and set up the connection to Vault CRM (^[69]). In practice, many organizations create a specific Permission Set for “X-Pages Author” that includes these rights.

• Content Organization: Use Domains and Distribution Channels in X-Pages Studio. Developers deploy CDEs and templates to a source domain, and content creators then import them into their Studio domain. For controlled releases, prepare distribution channels (test vs. prod) so content can be validated prior to going live. Veeva recommends content creators embed versioning info (timestamps, comments) in their ZIP to track changes.

• Offline and Sync Behavior: Remember that iPad users will only see the data that has been synced to their device. If a dashboard queries large static data sets (e.g. full product catalog), that data must first be synced (or prefetched via Nitro sync). Some X-Pages elements only work online. Veeva documentation notes certain quotas on offline storage and advises designers to keep pages performant.

• Performance Considerations: Minimize data weight. Use Nitro/QueryDataEngine for heavy queries, and filter on indexed fields. Avoid pulling entire objects when possible. Test performance on actual devices. Veeva’s platform imposes some limits (e.g. on maximum records fetched, total attachment size for mobile). Using Studio’s chart elements (which perform queries in the platform) can sometimes be more efficient than writing ad hoc ds.queryRecord.

• Version Control and CI: For larger teams, treat custom X-Pages code like any software project. Maintain source code in Git or similar, and generate ZIP artifacts for deployment. Although Vault CRM stores the attachments as static content, one can use a Continuous Integration approach to build/test X-Pages packages and automatically upload them (via the Vault API or metadata API). Veeva provides tooling (npm packages, GitHub actions) for automating some of this.

• Documentation and Training: Veeva offers flightpath courses and certification for MyInsights/X-Pages. Administrators should train business users on Studio and developers on the API. Because custom dashboards interact with core sales processes, it is important to align on naming conventions, maintenance responsibilities, and update processes. Usage metrics should be tracked: Vault CRM can log clicks on X-Pages elements (as shown in GSK’s practice (^[70])), enabling iterative improvements.

By following these guidelines, companies can ensure that X-Pages dashboards are robust, secure, and effective. The flexibility of the system means dashboard governance is as critical as the technical build.

Future Directions and Implications

As of late 2025, X-Pages stands at an advanced stage, but Veeva’s product roadmap signals several future growth areas:

• AI and Natural Language: Veeva has aggressively embraced AI for Vault CRM. In November 2024, Veeva announced Vault CRM Bot (a generative LLM assistant) and Voice Control coming in late 2025 (^[7]). CRM Bot will embed a user’s choice of LLM to suggest actions, perform queries, and provide guided insights (e.g. “summarize this territory’s trends”). This could be integrated with X-Pages by allowing reps to ask questions of their dashboards or get context-sensitive recommendations. For example, a rep might use voice or chat to ask, “Which products in this territory are underperforming?” The Bot could run a background query and highlight that in an X-Page. Veeva’s focus is on high-impact use cases: generative AI will not just make charts, but will use the data to offer “context-driven tasks” (pre-call advice, content recommendations) (^[7]). For dashboard development, this implies future versions of X-Pages may include AI-powered widgets (e.g. text summaries, anomaly detection) out-of-the-box.

• Voice and Mobile Interaction: The introduction of Voice Control (leveraging Apple Intelligence for iOS) means field users will be able to navigate CRM hands-free. In practice, this could allow voice-driven querying of dashboards or triggering the display of an X-Page. For instance, a rep could say “Show territory inventory dashboard”, and the app would load the appropriate X-Page automatically. These features are planned for 2025 and will make X-Pages more accessible in environments where typing is difficult (e.g. during calls or while driving between calls).

• Expanded Use Cases: Vault CRM is growing with new modules. The December 2025 release included Patient CRM, a module for managing patient journeys and support programs (^[71]). X-Pages will naturally extend into these areas. For example, patient support reps could see dashboards of patient enrollment by condition, or adherence metrics per clinic. According to Veeva, Patient CRM features detailed journey tracking and intervention management (^[72]) – data ripe for dashboarding. Similarly, Vault CRM Align (territory alignment data) was introduced in 25R2.0 (^[9]). Future X-Pages could incorporate alignment analytics: e.g. dashboards showing territory coverage vs. plan. As CRM modules converge, the distinction between “commercial” and “patient” dashboards will blur; X-Pages provides a unified framework for all these.

• Cross-Platform Evolution: In 2026 and beyond, X-Pages could reach beyond Vault CRM. For example, partner products like Veeva Commercial Analytics (formerly Crossix) or third-party platforms might embed X-Pages content via APIs. There is also potential for Lightning Web Components support in pure Salesforce environments (for non-Vault customers) as hinted by developer docs (^[13]).

• Standards and Governance: As X-Pages usage matures, we expect more emphasis on dashboards as “governed deliverables”. Industry trends (and data privacy laws) will push companies to document what data feeds each dashboard and to ensure compliance (e.g. only aggregated PHI in patient dashboards). X-Pages Studio may in future integrate with governance tools to track metadata lineage. The concept of “explainable dashboard” (where users can drill into calculations) may also grow.

• Competing Approaches: Outside of Veeva, other CRM analytics exist (e.g. Salesforce Einstein Analytics/CRM Analytics). However, in life sciences Veeva’s domain specificity is a major advantage. X-Pages’ future lies in being more than just dashboards – potentially the “front-end of Vault CRM’s analytics suite”, integrating with Nitro lockdowns, cross-product funnels, and machine learning. As lifecycle data (from R&D to patient outcomes) becomes more integrated, X-Pages-like interfaces could span across systems (though deeply embedded in Veeva’s ecosystem).

In summary, X-Pages is poised to remain Veeva’s primary tool for embedded analytics and dashboards. The combination of no-code studio, full customizability, and upcoming AI features suggests that by 2026 it will support a very broad range of use cases – from standard sales dashboards to sophisticated decision-support “agents”. The implications for life sciences firms are significant: better data-driven decision-making, tighter alignment between analytics and action, and potentially new business processes illuminated by accessible insights.

Conclusion

Veeva Vault CRM X-Pages represents a culmination of years of development in life-sciences CRM analytics. It brings interactive, context-sensitive dashboards directly to the point of use, in a platform that field users already rely on. By leveraging standards-based web technologies and Veeva’s data platform, X-Pages delivers both flexibility (fully custom HTML/JS pages) and ease of use (no-code Studio templates).

The benefits to life sciences organizations include improved salesforce productivity, more informed customer interactions, and a unified view of data. These benefits are supported by early adopter evidence (e.g. 30 minutes/day saved per rep (^[4])) and high satisfaction ratings. More broadly, X-Pages embodies the industry shift toward embedded analytics: instead of separate BI tools, analytics come to the user in context (^[2]) (^[21]).

This report has provided a detailed examination of X-Pages, covering its history, technical architecture, content creation workflows, data integration capabilities, and case examples. All claims have been substantiated with citations. We have shown that X-Pages is a mature, comprehensive framework – much more than just charting – tailored for the regulated, data-intensive world of life sciences.

Looking forward, we have argued that X-Pages will evolve with advances in AI, Voice, and CRM integration. The upcoming Vault CRM Bot (LLM assistant) and voice interfaces promise to make dashboards even more interactive and intuitive (^[7]). New data domains (patient data, territory assignments) will broaden X-Pages’ scope. Practitioners and researchers should watch how X-Pages and similar platforms continue to blur the line between analytics and workflow.

In conclusion, Veeva X-Pages is the current state-of-the-art for custom embedded dashboards in life sciences CRM. Its design balances developer extensibility with admin-level configurability. For a company aligning commercial data, patient data, and analytics, understanding and effectively implementing X-Pages is of strategic importance. This report has laid out the comprehensive context, capabilities, and best practices for those purposes, drawing on Veeva’s own documentation (^[5]) (^[2]) and authoritative industry analysis (^[4]) (^[7]).