diff --git a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/centre/tg-entity-centre-behavior.js b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/centre/tg-entity-centre-behavior.js
index 55dd8f9491..dd1b1b8be5 100644
--- a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/centre/tg-entity-centre-behavior.js
+++ b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/centre/tg-entity-centre-behavior.js
@@ -822,20 +822,25 @@ const TgEntityCentreBehaviorImpl = {
         }
     },
 
+    /**
+     * Pushes the current page of run data into the EGI and synchronises centre-level `retrievedEntities` / `renderingHints`.
+     *
+     * The EGI side arrays are primed before `retrievedEntities` is assigned, so the single `egiModel` rebuild (triggered by the EGI `entities` assignment inside the `retrievedEntities` observer) consumes fresh values in one pass.
+     * Assigning them after `retrievedEntities` (as was done previously) made the rebuild read stale values and then triggered a redundant per-row refresh pass for each array.
+     * `renderingHints` is assigned the same array reference that was primed, so the EGI-forwarding observer dirty-checks it into a no-op.
+     */
     _setPageData: function (startIdx, endIdx) {
-        if (typeof startIdx === 'undefined') {
-            this.retrievedEntities = this.allFilteredEntities;
-            this.renderingHints = this.allFilteredRenderingHints;
-            this.$.egi.primaryActionIndices = this.allFilteredPrimaryActionIndices;
-            this.$.egi.secondaryActionIndices = this.allFilteredSecondaryActionIndices;
-            this.$.egi.propertyActionIndices = this.allFilteredPropertyActionIndices;
-        } else {
-            this.retrievedEntities = this.allFilteredEntities.slice(startIdx, endIdx);
-            this.renderingHints = this.allFilteredRenderingHints.slice(startIdx, endIdx);
-            this.$.egi.primaryActionIndices = this.allFilteredPrimaryActionIndices.slice(startIdx, endIdx);
-            this.$.egi.secondaryActionIndices = this.allFilteredSecondaryActionIndices.slice(startIdx, endIdx);
-            this.$.egi.propertyActionIndices = this.allFilteredPropertyActionIndices.slice(startIdx, endIdx);
-        }
+        const page = arr => typeof startIdx === 'undefined' ? arr : arr.slice(startIdx, endIdx);
+        const entities = page(this.allFilteredEntities);
+        const renderingHints = page(this.allFilteredRenderingHints);
+        this.$.egi.primeGridData({
+            renderingHints: renderingHints,
+            primaryActionIndices: page(this.allFilteredPrimaryActionIndices),
+            secondaryActionIndices: page(this.allFilteredSecondaryActionIndices),
+            propertyActionIndices: page(this.allFilteredPropertyActionIndices)
+        });
+        this.retrievedEntities = entities;
+        this.renderingHints = renderingHints;
     },
 
     _setPageNumber: function (number) {
diff --git a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/components/fullcalendar/tg-fullcalendar.js b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/components/fullcalendar/tg-fullcalendar.js
index b71d37a806..4a09ab4e4c 100644
--- a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/components/fullcalendar/tg-fullcalendar.js
+++ b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/components/fullcalendar/tg-fullcalendar.js
@@ -171,6 +171,10 @@ export class TgFullcalendar extends mixinBehaviors([IronResizableBehavior], Poly
         super();
         this._reflector = new TgReflector();
         this._appConfig = new TgAppConfig();
+        // Raised when an event source rebuild is requested while the calendar is hidden; flushed by `_resizeEventListener` once the calendar becomes visible.
+        this._pendingEventSourceUpdate = false;
+        // Latches whether a deferred rebuild still owes a navigate-to-first-event: a run deferred while hidden must navigate on flush even if a later refresh arrives before the flush.
+        this._pendingNavigate = false;
     }
 
     ready () {
@@ -309,94 +313,134 @@ export class TgFullcalendar extends mixinBehaviors([IronResizableBehavior], Poly
     }
 
     /**
-     * Updates calendar data; moves it to the date of the chronologically first event (if any); re-renders calendar.
+     * Updates calendar data; moves it to the date of the chronologically first event (if any).
+     *
+     * While the calendar is hidden (`offsetParent === null`, e.g. a non-selected alternative view that `iron-pages` hides via `display: none`),
+     * the rebuild is skipped — a pending flag is raised instead and `_resizeEventListener` flushes it upon the `iron-resize` event that accompanies becoming visible.
+     * This avoids rebuilding the whole event source on every centre run while the calendar cannot be seen.
      */
     _updateEventSource(entities, eventKeyProperty, eventDescProperty, eventFromProperty, eventToProperty, _calendar) {
+        if (!_calendar) {
+            return;
+        }
+        if (this.offsetParent === null) {
+            this._pendingEventSourceUpdate = true;
+            // Latch the navigation intent at defer time: `dataChangeReason` reflects only the latest update, so a refresh arriving later while still hidden must not cancel the navigation owed to an earlier deferred run.
+            this._pendingNavigate = this._pendingNavigate || this.dataChangeReason !== RunActions.refresh;
+            return;
+        }
+        // This rebuild supersedes any deferred one, consuming a latched navigation if such is owed.
+        this._pendingEventSourceUpdate = false;
+        const shouldNavigate = this._pendingNavigate || this.dataChangeReason !== RunActions.refresh;
+        this._pendingNavigate = false;
+        this._rebuildEventSource(entities, eventKeyProperty, eventDescProperty, eventFromProperty, eventToProperty, _calendar, shouldNavigate);
+    }
+
+    /**
+     * Rebuilds calendar events from `entities`, navigating to the chronologically first event (if any) when `shouldNavigate` is true; the calendar re-renders exactly once.
+     *
+     * All mutations are grouped under `batchRendering` because FullCalendar otherwise re-renders synchronously after every single mutation
+     * (each removed event, each added event, each navigation) — an unbatched rebuild triggers thousands of re-renders for large result sets.
+     * The single re-render happens when the batch completes, hence no explicit `render()` call.
+     */
+    _rebuildEventSource(entities, eventKeyProperty, eventDescProperty, eventFromProperty, eventToProperty, _calendar, shouldNavigate) {
         // Sentinels for open-ended events. Far enough outside any plausible calendar view to behave like ±infinity.
         const FAR_PAST = moment('1900-01-01').toDate();
         const FAR_FUTURE = moment('2200-01-01').toDate();
-        if (allDefined(entities, eventKeyProperty, eventDescProperty, eventFromProperty, eventToProperty) && _calendar) {
-            _calendar.getEvents().forEach(event => event.remove());
-            let startTime = Infinity;
-            // Month view shows a single continuous bar per entity; time-grid views split into timed + allDay segments.
-            const isMonth = this.currentView === 'dayGridMonth';
-            entities.forEach(entity => {
-                if (startTime > entity.get(eventFromProperty)) {
-                    startTime = entity.get(eventFromProperty);
-                }
-                const eventColor = this.colorProperty ? entity.get(this.colorProperty) : undefined;
-                const startVal = entity.get(eventFromProperty);
-                const endVal = entity.get(eventToProperty);
-                const common = {
-                    extendedProps: { entity: entity },
-                    title: entity.get(eventKeyProperty) + (eventDescProperty && entity.get(eventDescProperty) ? " - "+ entity.get(eventDescProperty) : ""),
-                    backgroundColor: eventColor ? '#' + eventColor["hashlessUppercasedColourValue"]  : "#3788d8",
-                    groupId: 'evt-' + entity.get('id')
-                };
-                if (isMonth) {
-                    if (!startVal && !endVal) {
+        if (allDefined(entities, eventKeyProperty, eventDescProperty, eventFromProperty, eventToProperty)) {
+            _calendar.batchRendering(() => {
+                _calendar.removeAllEvents();
+                let startTime = Infinity;
+                // Month view shows a single continuous bar per entity; time-grid views split into timed + allDay segments.
+                const isMonth = this.currentView === 'dayGridMonth';
+                entities.forEach(entity => {
+                    const startVal = entity.get(eventFromProperty);
+                    const endVal = entity.get(eventToProperty);
+                    // Events without a start date must not participate in `startTime`, otherwise a single such event would suppress the navigation below.
+                    if (startVal && startTime > startVal) {
+                        startTime = startVal;
+                    }
+                    const eventColor = this.colorProperty ? entity.get(this.colorProperty) : undefined;
+                    const common = {
+                        extendedProps: { entity: entity },
+                        title: entity.get(eventKeyProperty) + (eventDescProperty && entity.get(eventDescProperty) ? " - "+ entity.get(eventDescProperty) : ""),
+                        backgroundColor: eventColor ? '#' + eventColor["hashlessUppercasedColourValue"]  : "#3788d8",
+                        groupId: 'evt-' + entity.get('id')
+                    };
+                    if (isMonth) {
+                        if (!startVal && !endVal) {
+                            _calendar.addEvent({ ...common, start: FAR_PAST, end: FAR_FUTURE, allDay: true });
+                        } else if (!startVal) {
+                            _calendar.addEvent({ ...common, start: FAR_PAST, end: endVal, allDay: true });
+                        } else if (!endVal) {
+                            _calendar.addEvent({ ...common, start: startVal, end: FAR_FUTURE, allDay: true });
+                        } else {
+                            _calendar.addEvent({ ...common, start: startVal, end: endVal });
+                        }
+                    } else if (!startVal && !endVal) {
                         _calendar.addEvent({ ...common, start: FAR_PAST, end: FAR_FUTURE, allDay: true });
                     } else if (!startVal) {
-                        _calendar.addEvent({ ...common, start: FAR_PAST, end: endVal, allDay: true });
+                        const end = moment(endVal);
+                        const endDayStart = end.clone().startOf('day');
+                        _calendar.addEvent({ ...common, start: FAR_PAST, end: endDayStart.toDate(), allDay: true });
+                        if (endDayStart.isBefore(end)) {
+                            _calendar.addEvent({ ...common, start: endDayStart.toDate(), end: end.toDate() });
+                        }
                     } else if (!endVal) {
-                        _calendar.addEvent({ ...common, start: startVal, end: FAR_FUTURE, allDay: true });
-                    } else {
-                        _calendar.addEvent({ ...common, start: startVal, end: endVal });
-                    }
-                } else if (!startVal && !endVal) {
-                    _calendar.addEvent({ ...common, start: FAR_PAST, end: FAR_FUTURE, allDay: true });
-                } else if (!startVal) {
-                    const end = moment(endVal);
-                    const endDayStart = end.clone().startOf('day');
-                    _calendar.addEvent({ ...common, start: FAR_PAST, end: endDayStart.toDate(), allDay: true });
-                    if (endDayStart.isBefore(end)) {
-                        _calendar.addEvent({ ...common, start: endDayStart.toDate(), end: end.toDate() });
-                    }
-                } else if (!endVal) {
-                    const start = moment(startVal);
-                    const allDayStart = start.clone().startOf('day');
-                    if (allDayStart.isBefore(start)) {
-                        allDayStart.add(1, 'day');
-                    }
-                    if (start.isBefore(allDayStart)) {
-                        _calendar.addEvent({ ...common, start: start.toDate(), end: allDayStart.toDate() });
-                    }
-                    _calendar.addEvent({ ...common, start: allDayStart.toDate(), end: FAR_FUTURE, allDay: true });
-                } else {
-                    const start = moment(startVal);
-                    const end = moment(endVal);
-                    const fullDayStart = start.clone().startOf('day');
-                    if (fullDayStart.isBefore(start)) {
-                        fullDayStart.add(1, 'day');
-                    }
-                    const fullDayEnd = end.clone().startOf('day');
-                    if (!fullDayStart.isBefore(fullDayEnd)) {
-                        _calendar.addEvent({ ...common, start: startVal, end: endVal });
+                        const start = moment(startVal);
+                        const allDayStart = start.clone().startOf('day');
+                        if (allDayStart.isBefore(start)) {
+                            allDayStart.add(1, 'day');
+                        }
+                        if (start.isBefore(allDayStart)) {
+                            _calendar.addEvent({ ...common, start: start.toDate(), end: allDayStart.toDate() });
+                        }
+                        _calendar.addEvent({ ...common, start: allDayStart.toDate(), end: FAR_FUTURE, allDay: true });
                     } else {
-                        if (start.isBefore(fullDayStart)) {
-                            _calendar.addEvent({ ...common, start: start.toDate(), end: fullDayStart.toDate() });
+                        const start = moment(startVal);
+                        const end = moment(endVal);
+                        const fullDayStart = start.clone().startOf('day');
+                        if (fullDayStart.isBefore(start)) {
+                            fullDayStart.add(1, 'day');
                         }
-                        // allDay events use exclusive end semantics in FullCalendar.
-                        _calendar.addEvent({ ...common, start: fullDayStart.toDate(), end: fullDayEnd.toDate(), allDay: true });
-                        if (fullDayEnd.isBefore(end)) {
-                            _calendar.addEvent({ ...common, start: fullDayEnd.toDate(), end: end.toDate() });
+                        const fullDayEnd = end.clone().startOf('day');
+                        if (!fullDayStart.isBefore(fullDayEnd)) {
+                            _calendar.addEvent({ ...common, start: startVal, end: endVal });
+                        } else {
+                            if (start.isBefore(fullDayStart)) {
+                                _calendar.addEvent({ ...common, start: start.toDate(), end: fullDayStart.toDate() });
+                            }
+                            // allDay events use exclusive end semantics in FullCalendar.
+                            _calendar.addEvent({ ...common, start: fullDayStart.toDate(), end: fullDayEnd.toDate(), allDay: true });
+                            if (fullDayEnd.isBefore(end)) {
+                                _calendar.addEvent({ ...common, start: fullDayEnd.toDate(), end: end.toDate() });
+                            }
                         }
                     }
-                }
-                if (this.dataChangeReason !== RunActions.refresh && startTime && startTime < Infinity) {
+                });
+                // Navigate once, after the earliest event start across all entities is known.
+                if (shouldNavigate && startTime < Infinity) {
                     _calendar.gotoDate(startTime);
                 }
             });
-            _calendar.render();
-        } else if (_calendar){
-            _calendar.gotoDate(new Date());
-            _calendar.getEvents().forEach(event => event.remove());
-            _calendar.render();
+        } else {
+            _calendar.batchRendering(() => {
+                _calendar.gotoDate(new Date());
+                _calendar.removeAllEvents();
+            });
         }
     }
 
     _resizeEventListener () {
         if (this._calendar) {
+            // Flushes an event source rebuild that was deferred while the calendar was hidden.
+            // `iron-resize` is guaranteed on becoming visible: `iron-pages` performs `notifyResize` on every selection change and the notification reaches this component through the resizable chain.
+            if (this._pendingEventSourceUpdate && this.offsetParent !== null) {
+                this._pendingEventSourceUpdate = false;
+                const shouldNavigate = this._pendingNavigate;
+                this._pendingNavigate = false;
+                this._rebuildEventSource(this.entities, this.eventKeyProperty, this.eventDescProperty, this.eventFromProperty, this.eventToProperty, this._calendar, shouldNavigate);
+            }
             this._calendar.render();
         }
     }
diff --git a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-egi-cell.js b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-egi-cell.js
index edc93b2714..03736f3c8c 100644
--- a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-egi-cell.js
+++ b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-egi-cell.js
@@ -7,6 +7,8 @@ import '/resources/polymer/@polymer/iron-icons/iron-icons.js';
 import '/resources/polymer/@polymer/paper-icon-button/paper-icon-button.js';
 import '/resources/polymer/@polymer/paper-styles/color.js';
 
+import '/resources/polymer/@polymer/polymer/lib/elements/dom-if.js';
+
 import { Polymer } from '/resources/polymer/@polymer/polymer/lib/legacy/polymer-fn.js';
 import { html } from '/resources/polymer/@polymer/polymer/lib/utils/html-tag.js';
 
@@ -17,6 +19,10 @@ import { simplifyRichText } from '/resources/components/rich-text/tg-rich-text-u
 export const EGI_CELL_PADDING = "0.6rem";
 export const EGI_CELL_PADDING_TEMPLATE = html`0.6rem`;
 
+// The overflow button at the bottom of the template is stamped via dom-if (rather than always stamped and toggled with hidden$) so that a cell whose column has no multi-group property actions never instantiates a paper-icon-button.
+// An EGI renders as a non-virtualized dom-repeat of tg-egi-cell (one instance per row per column), so an always-stamped per-cell paper-icon-button would boot tens of thousands of elements on a large centre — a significant, purely wasted rendering cost, since almost all cells keep it hidden.
+// _hasOverflow depends only on column configuration (stable per column), so dom-if stamps the button once for the columns that need it and never for those that do not.
+// This explanation lives outside the html literal deliberately — a comment inside would be cloned as a comment node into every stamped cell instance.
 const template = html`
     <style>
         :host {
@@ -130,7 +136,9 @@ const template = html`
     <iron-icon class="table-icon" hidden$="[[!_isBooleanProp(_hostComponent, _entity, column)]]" style$="[[_foregroundRendHints]]" icon="[[_value]]"></iron-icon>
     <a class="value-container" hidden$="[[!_isHyperlinkProp(_hostComponent, _entity, column)]]" href$="[[_value]]" target="_blank" style$="[[_foregroundRendHints]]">[[_value]]</a>
     <div class="value-container" word-wrap$="[[column.wordWrap]]" hidden$="[[!_isNotBooleanOrHyperlinkProp(_hostComponent, _entity, column)]]" style$="[[_foregroundRendHints]]" inner-h-t-m-l="[[_value]]"></div>
-    <paper-icon-button id="dropdownAction" class="overflow-button" icon="more-vert" hidden$="[[!_hasOverflow(column)]]" on-tap="_openOverflow" tooltip-text="Opens list of available actions"></paper-icon-button>`;
+    <template is="dom-if" if="[[_hasOverflow(column)]]">
+        <paper-icon-button id="dropdownAction" class="overflow-button" icon="more-vert" on-tap="_openOverflow" tooltip-text="Opens list of available actions"></paper-icon-button>
+    </template>`;
 
 Polymer({
 
@@ -344,11 +352,12 @@ Polymer({
     /**
      * Opens the shared EGI dropdown with this column's property-action groups, positioned next to the overflow button.
      * Stops event propagation so the click does not also fire the cell-tap (which would re-run the first action).
+     * The overflow button is stamped inside a dom-if, so it is resolved via `$$` rather than the static `this.$` map (dynamic node ids are not registered in `this.$`).
      */
     _openOverflow: function (e) {
         e.stopPropagation();
         if (this._hostComponent && this._entity && this.column) {
-            this._hostComponent._openDropDownForPropertyActions(this._entity, this.column, this.$.dropdownAction);
+            this._hostComponent._openDropDownForPropertyActions(this._entity, this.column, this.$$('#dropdownAction'));
         }
     }
 });
\ No newline at end of file
diff --git a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-entity-grid-inspector.js b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-entity-grid-inspector.js
index f5f4eb4aac..86ab4351fb 100644
--- a/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-entity-grid-inspector.js
+++ b/platform-web-ui/src/main/web/ua/com/fielden/platform/web/egi/tg-entity-grid-inspector.js
@@ -32,6 +32,7 @@ import { TgShortcutProcessingBehavior } from '/resources/actions/tg-shortcut-pro
 import { TgSerialiser } from '/resources/serialisation/tg-serialiser.js';
 import { getKeyEventTarget, tearDownEvent, getRelativePos, isMobileApp, resultMessages, getFirstEntityTypeAndProperty } from '/resources/reflection/tg-polymer-utils.js';
 import { checkLinkAndOpen } from '/resources/components/tg-link-opener.js';
+import { hideTooltip } from '/resources/components/tg-tooltip-behavior.js';
 
 const EGI_BOTTOM_MARGIN = "15px";
 const EGI_BOTTOM_MARGIN_TEMPLATE = html`15px`;
@@ -456,6 +457,14 @@ const template = html`
                 <slot name="save-button"></slot>
             </div>
             <!--Table body-->
+            <!--
+              This comment sits outside the body dom-repeat deliberately — template content is cloned per stamped instance, so an in-row comment would be replicated as a comment node for every row.
+              The per-column dom-repeat tags inside the row template do NOT need mutable-data.
+              The staleness-prone fields (property, keyProperty, valueProperty) are read inside <tg-egi-cell> via observers that re-fire on egiEntity change — picking up fresh column metadata at that point (the ordering fix in _postRun ensures dynamicColumns is applied before allRetrievedEntities triggers egi-model rebuild).
+              Other deep-path bindings that do appear there (e.g. column.width) are on properties that are either static or updated via Polymer's set() (e.g. column resizing), so they propagate through path notification regardless of mutable-data.
+              If a deep-path binding on a property mutated by the centre-side dynamicColumns dom-repeat (e.g. [[column.columnTitle]]) is ever added, mutable-data would be required on both body-row templates.
+              Cell tooltips are deliberately NOT bound in the cell tags — they are computed on demand by _provideCellTooltip (on hover), because eager per-cell computation is expensive at rows × columns scale while a tooltip is only ever read at hover time.
+            -->
             <template is="dom-repeat" items="[[egiModel]]" as="egiEntity" index-as="entityIndex" on-dom-change="_scrollContainerEntitiesStamped">
                 <div class="table-data-row" is-editing$="[[egiEntity.editing]]" on-mouseenter="_mouseRowEnter" on-mouseleave="_mouseRowLeave">
                     <div class="drag-anchor cell" show-left-shadow$="[[_dragAnchorShadowVisible(canDragFrom, dragAnchorFixed, checkboxesFixed, _showLeftShadow)]]" draggable$="[[_isDraggable(egiEntity.selected)]]" selected$="[[egiEntity.selected]]" over$="[[egiEntity.over]]" hidden$="[[!canDragFrom]]" style$="[[_calcDragBoxStyle(dragAnchorFixed)]]">
@@ -467,19 +476,13 @@ const template = html`
                     <div class="action-cell cell" show-left-shadow$="[[_primaryActionShadowVisible(primaryAction, checkboxesWithPrimaryActionsFixed, numOfFixedCols, _showLeftShadow)]]" hidden$="[[!primaryAction]]" selected$="[[egiEntity.selected]]" over$="[[egiEntity.over]]" style$="[[_calcPrimaryActionStyle(canDragFrom, checkboxVisible, checkboxesWithPrimaryActionsFixed)]]">
                         <tg-egi-multi-action class="action" actions="[[primaryAction.actions]]" current-entity="[[_currentEntity(egiEntity.entity)]]" chosen-entity="[[_currentEntity(egiEntity.entity)]]" current-index="[[egiEntity.primaryActionIndex]]"></tg-egi-multi-action>
                     </div>
-                    <!--
-                      Body-row dom-repeat tags below do NOT need mutable-data.
-                      The staleness-prone fields (property, keyProperty, valueProperty) are read inside <tg-egi-cell> via observers that re-fire on egiEntity change — picking up fresh column metadata at that point (the ordering fix in _postRun ensures dynamicColumns is applied before allRetrievedEntities triggers egi-model rebuild).
-                      Other deep-path bindings that do appear here (e.g. column.width, column.customActions) are on properties that are either static or updated via Polymer's set() (e.g. column resizing), so they propagate through path notification regardless of mutable-data.
-                      If a deep-path binding on a property mutated by the centre-side dynamicColumns dom-repeat (e.g. [[column.columnTitle]]) is ever added here, mutable-data would be required on both body-row templates.
-                    -->
                     <div class="fixed-columns-container" show-left-shadow$="[[_fixedColsShadowVisible(numOfFixedCols, _showLeftShadow)]]" hidden$="[[!numOfFixedCols]]" style$="[[_calcFixedColumnContainerStyle(canDragFrom, checkboxVisible, primaryAction, numOfFixedCols)]]">
                         <template is="dom-repeat" items="[[fixedColumns]]" as="column">
-                            <tg-egi-cell class="cell" selected$="[[egiEntity.selected]]" over$="[[egiEntity.over]]" column="[[column]]" egi-entity="[[egiEntity]]" style$="[[_calcColumnStyle(column, column.width, column.growFactor, column.shouldAddDynamicWidth, 'true')]]" tooltip-text$="[[_getTooltip(egiEntity.entity, column, column.customActions)]]" with-action="[[hasAction(egiEntity.entity, column)]]" on-tap="_tapFixedAction"></tg-egi-cell>
+                            <tg-egi-cell class="cell" selected$="[[egiEntity.selected]]" over$="[[egiEntity.over]]" column="[[column]]" egi-entity="[[egiEntity]]" style$="[[_calcColumnStyle(column, column.width, column.growFactor, column.shouldAddDynamicWidth, 'true')]]" with-action="[[hasAction(egiEntity.entity, column)]]" on-tap="_tapFixedAction"></tg-egi-cell>
                         </template>
                     </div>
                     <template is="dom-repeat" items="[[columns]]" as="column">
-                        <tg-egi-cell class="cell" selected$="[[egiEntity.selected]]" over$="[[egiEntity.over]]" column="[[column]]" egi-entity="[[egiEntity]]" style$="[[_calcColumnStyle(column, column.width, column.growFactor, column.shouldAddDynamicWidth, 'false')]]" tooltip-text$="[[_getTooltip(egiEntity.entity, column, column.customActions)]]" with-action="[[hasAction(egiEntity.entity, column)]]" on-tap="_tapAction"></tg-egi-cell>
+                        <tg-egi-cell class="cell" selected$="[[egiEntity.selected]]" over$="[[egiEntity.over]]" column="[[column]]" egi-entity="[[egiEntity]]" style$="[[_calcColumnStyle(column, column.width, column.growFactor, column.shouldAddDynamicWidth, 'false')]]" with-action="[[hasAction(egiEntity.entity, column)]]" on-tap="_tapAction"></tg-egi-cell>
                     </template>
                     <div class="action-cell cell" show-right-shadow$="[[_rightShadowVisible(_isSecondaryActionPresent, _showRightShadow)]]" selected$="[[egiEntity.selected]]" over$="[[egiEntity.over]]" hidden$="[[!_isSecondaryActionPresent]]" style$="[[_calcSecondaryActionStyle(secondaryActionsFixed)]]">
                         <tg-secondary-action-button class="action" actions="[[_secondaryActions]]" current-indices="[[egiEntity.secondaryActionIndices]]" current-entity="[[_currentEntity(egiEntity.entity)]]" chosen-entity="[[_currentEntity(egiEntity.entity)]]" is-single="[[_isSingleSecondaryAction]]" dropdown-trigger="[[_openDropDownForSecondaryActions]]"></tg-secondary-action-button>
@@ -591,6 +594,32 @@ function updateSelectAll (egi, egiModel) {
     }
 };
 
+function entityIdOf(entity) {
+    return entity && typeof entity.get === 'function' ? entity.get('id') : null;
+};
+
+function buildEntityIndexMaps (entities) {
+    const byRef = new Map();
+    (entities || []).forEach((entity, index) => {
+        if (!byRef.has(entity)) {
+            byRef.set(entity, index);
+        }
+    });
+    // `byId` encodes the id-first half of `_areEqual`'s equality rule and is built lazily by `findEntityIndex` upon the first `byRef` miss — the dominant rendering path (same references) never needs it.
+    return { byRef: byRef, byId: null };
+};
+
+function buildEntityIdMap(entities) {
+    const byId = new Map();
+    (entities || []).forEach((entity, index) => {
+        const id = entityIdOf(entity);
+        if (id && !byId.has(id)) {
+            byId.set(id, index);
+        }
+    });
+    return byId;
+};
+
 function _insertMaster (container, egiMaster, entityIndex) {
     const row = container.querySelectorAll(".table-data-row")[entityIndex];
     container.insertBefore(egiMaster, row.nextSibling);
@@ -866,6 +895,15 @@ Polymer({
         this._totalsRowCount = 0;
         this._showProgress = false;
 
+        //Memoised entity → index maps used by findEntityIndex; invalidated on each `entities` assignment and rebuilt lazily.
+        this._entityIndexMaps = null;
+        //Batch-assignment flag: suppresses the per-row refresh observers (rendering hints / action indices) while primeGridData assigns them ahead of an entities-triggered egiModel rebuild.
+        this._suppressPerRowRefresh = false;
+        //The body cell for which a hover tooltip was last computed by _provideCellTooltip.
+        this._lastTooltipCell = null;
+        //Body cells currently carrying a computed `tooltip-text` attribute; lets model rebuilds clear them without scanning all stamped cells.
+        this._cellsWithTooltip = new Set();
+
         //Initialising shadows
         this._showTopShadow = false;
         this._showBottomShadow = false;
@@ -908,6 +946,14 @@ Polymer({
         //Initialising event listeners.
         this.addEventListener("iron-resize", this._resizeEventListener.bind(this));
 
+        //Compute body cell tooltips lazily on hover instead of eagerly for every stamped cell.
+        //`mouseover` / `touchstart` are dispatched before the events that TgTooltipBehavior reacts to on its (ancestor) trigger element, so the `tooltip-text` attribute is in place by the time it is read.
+        //`mousemove` covers a pointer already resting inside a cell whose tooltip was invalidated (model rebuild, in-place update) — no boundary crossing happens there; the identity guard keeps the recompute a no-op otherwise.
+        this._provideCellTooltip = this._provideCellTooltip.bind(this);
+        this.$.baseContainer.addEventListener("mouseover", this._provideCellTooltip);
+        this.$.baseContainer.addEventListener("mousemove", this._provideCellTooltip);
+        this.$.baseContainer.addEventListener("touchstart", this._provideCellTooltip, { passive: true });
+
         //Observe column DOM changes
         new FlattenedNodesObserver(this.$.column_selector, (info) => {
             this._columnDomChanged(info.addedNodes, info.removedNodes);
@@ -1003,6 +1049,8 @@ Polymer({
             const egiEntity = this.egiModel[entityIndex];
             egiEntity.entity.set(propPath, entity.get(propPath));
             egiEntity._propertyChangedHandlers && egiEntity._propertyChangedHandlers[propPath] && egiEntity._propertyChangedHandlers[propPath]();
+            // In-place value / validation changes alter tooltip content without an egiModel rebuild — the hovered cell must not keep serving its cached tooltip.
+            this._invalidateHoveredCellTooltip();
         }
     },
 
@@ -1021,7 +1069,31 @@ Polymer({
         }
     },
     
+    /**
+     * Returns the index of `entity` in `entities`, resolved through memoised identity / id maps.
+     *
+     * This method sits on the per-cell rendering path (`hasAction` bindings, cell tooltips) — a linear `_findEntity` scan here made rendering cost quadratic in the number of rows.
+     * The maps mirror `_areEqual`'s id-first matching rule (with `entityIdOf` as the shared id-extraction helper) and are rebuilt lazily after each `entities` assignment;
+     * inputs that miss both maps (e.g. equal-by-key instances without an id) fall back to the original linear scan.
+     */
     findEntityIndex: function (entity) {
+        if (!this._entityIndexMaps) {
+            this._entityIndexMaps = buildEntityIndexMaps(this.entities);
+        }
+        const indexByRef = this._entityIndexMaps.byRef.get(entity);
+        if (typeof indexByRef !== 'undefined') {
+            return indexByRef;
+        }
+        const id = entityIdOf(entity);
+        if (id) {
+            if (this._entityIndexMaps.byId === null) {
+                this._entityIndexMaps.byId = buildEntityIdMap(this.entities);
+            }
+            const indexById = this._entityIndexMaps.byId.get(id);
+            if (typeof indexById !== 'undefined') {
+                return indexById;
+            }
+        }
         return this._findEntity(entity, this.entities);
     },
     
@@ -1064,6 +1136,25 @@ Polymer({
         }
     },    
 
+    /**
+     * Primes all run-produced row data (rendering hints and action indices) in one batch, ahead of an imminent `entities` assignment.
+     *
+     * The arrays are assigned with per-row refresh suppressed: their observers (`_renderingHintsChanged`, `_primaryActionIndicesChanged`, `_secondaryActionIndicesChanged`)
+     * would otherwise walk the soon-to-be-replaced `egiModel` performing a per-row `set` each, while the `egiModel` rebuild triggered by the subsequent `entities` assignment consumes these arrays anyway.
+     * Individual property assignments remain fully supported for callers that update one aspect at a time outside of a run.
+     */
+    primeGridData: function (gridData) {
+        this._suppressPerRowRefresh = true;
+        try {
+            this.renderingHints = gridData.renderingHints;
+            this.primaryActionIndices = gridData.primaryActionIndices;
+            this.secondaryActionIndices = gridData.secondaryActionIndices;
+            this.propertyActionIndices = gridData.propertyActionIndices;
+        } finally {
+            this._suppressPerRowRefresh = false;
+        }
+    },
+
     //Filtering related functions
     filter: function () {
         const tempFilteredEntities = [];
@@ -1394,7 +1485,8 @@ Polymer({
 
     //Entities changed related functions
     _entitiesChanged: function (newEntities, oldEntities) {
-        this.filter();  
+        this._entityIndexMaps = null; // rebuilt lazily by findEntityIndex
+        this.filter();
     },
 
     _filteredEntitiesChanged: function (newValue) {
@@ -1429,11 +1521,18 @@ Polymer({
         });
         updateSelectAll(this, tempEgiModel);
         this.egiModel = tempEgiModel;
+        // Tooltips computed for the previous model are dropped and recomputed on the next pointer movement; only cells that actually received a tooltip are touched.
+        // The hovered cell is invalidated first — this also dismisses a displayed (frozen) or pending tooltip that would otherwise outlive its data.
+        this._invalidateHoveredCellTooltip();
+        this._cellsWithTooltip.forEach(cell => cell.removeAttribute("tooltip-text"));
+        this._cellsWithTooltip.clear();
         this._updateTableSizeAsync();
         this.fire("tg-egi-entities-loaded", newValue);
     },
 
     _updateColumns: function (resultantColumns) {
+        // Column reconfiguration can rebind the hovered cell to a different column without an egiModel rebuild — its cached tooltip must not survive.
+        this._invalidateHoveredCellTooltip();
         // First filter the columns to include only authorized (i.e., visible) columns.
         const availableColumns = resultantColumns.filter(col => !col.isHidden);
         this.fixedColumns = availableColumns.splice(0, this.numOfFixedCols);
@@ -2052,6 +2151,9 @@ Polymer({
     },
 
     _renderingHintsChanged: function (newValue) {
+        if (this._suppressPerRowRefresh) {
+            return; // primed ahead of an entities-triggered rebuild, which consumes the new value itself
+        }
         if (this.egiModel) {
             const noneFilteredOut = this.egiModel.length === this.entities.length;
             this.egiModel.forEach((egiEntity, egiEntIndex) => {
@@ -2063,6 +2165,9 @@ Polymer({
     },
 
     _primaryActionIndicesChanged: function (newValue) {
+        if (this._suppressPerRowRefresh) {
+            return; // primed ahead of an entities-triggered rebuild, which consumes the new value itself
+        }
         if (this.egiModel) {
             const noneFilteredOut = this.egiModel.length === this.entities.length;
             this.egiModel.forEach((egiEntity, index) => {
@@ -2072,6 +2177,9 @@ Polymer({
     },
 
     _secondaryActionIndicesChanged: function (newValue) {
+        if (this._suppressPerRowRefresh) {
+            return; // primed ahead of an entities-triggered rebuild, which consumes the new value itself
+        }
         if (this.egiModel) {
             const noneFilteredOut = this.egiModel.length === this.entities.length;
             this.egiModel.forEach((egiEntity, index) => {
@@ -2199,6 +2307,49 @@ Polymer({
         };
     },
 
+    /**
+     * Installs the `tooltip-text` attribute on the body cell under the pointer, computing the tooltip on demand.
+     *
+     * Cell tooltips used to be bound eagerly in the row templates, which computed rows × columns tooltip HTML strings on every model rebuild,
+     * while `TgTooltipBehavior` reads the attribute only at hover time (and `tg-tooltip` shows it after a further delay).
+     * Only body row cells participate — totals cells keep their eager `_getTotalTooltip` binding.
+     */
+    _provideCellTooltip: function (event) {
+        const cell = event.target && event.target.closest ? event.target.closest("tg-egi-cell") : null;
+        if (cell === this._lastTooltipCell) {
+            return;
+        }
+        this._lastTooltipCell = cell;
+        if (cell && cell.egiEntity && cell.column && cell.closest(".table-data-row")) {
+            const tooltip = this._getTooltip(cell.egiEntity.entity, cell.column, cell.column.customActions);
+            if (tooltip) {
+                cell.setAttribute("tooltip-text", tooltip);
+                this._cellsWithTooltip.add(cell);
+            } else {
+                cell.removeAttribute("tooltip-text");
+                this._cellsWithTooltip.delete(cell);
+            }
+        }
+    },
+
+    /**
+     * Drops the tooltip computed for the currently hovered cell so that the next pointer movement recomputes it.
+     * Used by the `egiModel` rebuild and by in-place update paths (`updateEntity`, column reconfiguration) that change what a visible tooltip should say.
+     *
+     * Refreshing the `tooltip-text` attribute alone is not enough: `tg-tooltip.show` is a no-op while a tooltip is already displayed (its content is frozen) and a pending show timer has captured the old text.
+     * Hence the displayed / pending tooltip is hidden as well — but only when the pointer is actually over the invalidated cell, leaving unrelated tooltips alone.
+     */
+    _invalidateHoveredCellTooltip: function () {
+        if (this._lastTooltipCell) {
+            this._lastTooltipCell.removeAttribute("tooltip-text");
+            this._cellsWithTooltip.delete(this._lastTooltipCell);
+            if (this._lastTooltipCell.matches(":hover")) {
+                hideTooltip();
+            }
+            this._lastTooltipCell = null;
+        }
+    },
+
     _getTooltip: function (entity, column, actions) {
         try {
             let tooltip = this.getValueTooltip(entity, column);