diff --git a/plugins/newspack-plugin/includes/plugins/class-perfmatters.php b/plugins/newspack-plugin/includes/plugins/class-perfmatters.php
index 59da3094c2..d776bf40f2 100644
--- a/plugins/newspack-plugin/includes/plugins/class-perfmatters.php
+++ b/plugins/newspack-plugin/includes/plugins/class-perfmatters.php
@@ -85,6 +85,46 @@ private static function scripts_to_delay() {
 		return $scripts_to_delay;
 	}
 
+	/**
+	 * Scripts on the reveal path of above-header prompts.
+	 *
+	 * These are excluded from JS delay when published above-header prompts exist so the
+	 * prompts show immediately: the Campaigns view script (newspack-popups) removes the
+	 * prompt's `hidden` class, and the reader data library (window.newspack /
+	 * newspack-plugin) drives that reveal when segments are configured.
+	 *
+	 * @return string[] Script identifiers.
+	 */
+	private static function above_header_reveal_scripts() {
+		return [ 'newspack-popups', 'window.newspack', 'newspack-plugin' ];
+	}
+
+	/**
+	 * Reveal-path scripts to exclude from JS deferral when above-header prompts exist.
+	 *
+	 * Derived from above_header_reveal_scripts() minus `window.newspack`: that token
+	 * matches an inline script, and Perfmatters' deferral only applies to external
+	 * `<script src>` files, so it is meaningless as a defer exclusion. Kept derived from
+	 * the reveal-script set so the delay and defer lists cannot silently drift.
+	 *
+	 * @return string[] Script identifiers.
+	 */
+	private static function above_header_defer_exclusions() {
+		return array_values( array_diff( self::above_header_reveal_scripts(), [ 'window.newspack' ] ) );
+	}
+
+	/**
+	 * Whether above-header prompts should be revealed immediately (excluded from JS
+	 * delay/deferral). True when the Campaigns plugin reports at least one published
+	 * above-header prompt.
+	 *
+	 * @return bool
+	 */
+	private static function has_immediate_above_header_prompts() {
+		return method_exists( 'Newspack_Popups_Model', 'has_published_above_header_prompts' )
+			&& \Newspack_Popups_Model::has_published_above_header_prompts();
+	}
+
 	/**
 	 * Stylesheets to exclude from the "Unused CSS" feature.
 	 */
@@ -151,15 +191,24 @@ private static function get_defaults( $options = [] ) {
 		// https://perfmatters.io/docs/disable-woocommerce-cart-fragments-ajax/
 		$options['disable_woocommerce_cart_fragmentation'] = true;
 
+		// Resolve once per filter pass – this is read on essentially every front-end
+		// request, and both the defer and delay blocks below need it (NPPM-2934).
+		$reveal_above_header = self::has_immediate_above_header_prompts();
+
 		// JS deferral.
 		if ( ! isset( $options['assets'] ) ) {
 			$options['assets'] = [];
 		}
-		$defer_js_exclusions           = [
+		$defer_js_exclusions = [
 			'wp-includes',
 			'jwplayer.com', // This platform won't work if the JS is deferred.
 			'adsrvr.org', // This platform won't work if the JS is deferred.
 		];
+		// When the site has published above-header prompts, exclude the prompt reveal
+		// scripts from deferral too, so they execute as early as possible (NPPM-2934).
+		if ( $reveal_above_header ) {
+			$defer_js_exclusions = array_merge( $defer_js_exclusions, self::above_header_defer_exclusions() );
+		}
 		$options['assets']['defer_js'] = true;
 		if ( isset( $options['assets']['js_exclusions'] ) && is_array( $options['assets']['js_exclusions'] ) ) {
 			$options['assets']['js_exclusions'] = array_unique(
@@ -175,16 +224,20 @@ private static function get_defaults( $options = [] ) {
 
 		// JS delay.
 		$options['assets']['delay_js'] = true;
+		$delay_js_inclusions           = self::scripts_to_delay();
 		if ( isset( $options['assets']['delay_js_inclusions'] ) && is_array( $options['assets']['delay_js_inclusions'] ) ) {
-			$options['assets']['delay_js_inclusions'] = array_unique(
-				array_merge(
-					$options['assets']['delay_js_inclusions'],
-					self::scripts_to_delay()
-				)
-			);
-		} else {
-			$options['assets']['delay_js_inclusions'] = self::scripts_to_delay();
+			$delay_js_inclusions = array_merge( $options['assets']['delay_js_inclusions'], $delay_js_inclusions );
+		}
+		// When the site has published above-header prompts, keep the scripts that reveal them
+		// out of the delay queue so the prompts appear immediately instead of after the first
+		// interaction. The subtraction runs on the merged list, not just on Newspack's own
+		// contribution: Perfmatters persists its delay list whenever its settings are saved
+		// through the UI, so on a configured site the stored list already contains the reveal
+		// scripts and merging alone would put them straight back (NPPM-2934).
+		if ( $reveal_above_header ) {
+			$delay_js_inclusions = array_diff( $delay_js_inclusions, self::above_header_reveal_scripts() );
 		}
+		$options['assets']['delay_js_inclusions'] = array_values( array_unique( $delay_js_inclusions ) );
 		$options['assets']['delay_timeout'] = true;
 		$options['assets']['fastclick']     = true;
 
diff --git a/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/index.js b/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/index.js
index 2f3928fa3d..0abeeff7a1 100644
--- a/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/index.js
+++ b/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/index.js
@@ -5,7 +5,7 @@
 /**
  * WordPress dependencies.
  */
-import { __experimentalVStack as VStack } from '@wordpress/components'; // eslint-disable-line @wordpress/no-unsafe-wp-apis
+import { Notice, __experimentalVStack as VStack } from '@wordpress/components'; // eslint-disable-line @wordpress/no-unsafe-wp-apis
 import { useContext, useEffect, useState, Fragment } from '@wordpress/element';
 import { __ } from '@wordpress/i18n';
 import { ENTER } from '@wordpress/keycodes';
@@ -17,7 +17,7 @@ import { moreVertical } from '@wordpress/icons';
 import { Button, Card, CustomSelectControl, Modal, Router, TextControl, withWizardScreen } from '../../../../../../packages/components/src';
 import CampaignManagementPopover from '../../../components/campaign-management-popover';
 import SegmentGroup from '../../../components/segment-group';
-import { dataForCampaignId } from '../utils';
+import { dataForCampaignId, isAboveHeader } from '../utils';
 import { CampaignsContext } from '../../../contexts';
 import './style.scss';
 
@@ -119,6 +119,7 @@ const Campaigns = props => {
 	const allPrompts = useContext( CampaignsContext );
 	const prompts = filterByCampaign( allPrompts, campaignId );
 	const hasUnassigned = filterByCampaign( allPrompts, 'unassigned' ).length;
+	const hasPublishedAboveHeader = allPrompts.some( prompt => 'publish' === prompt.status && isAboveHeader( prompt ) );
 
 	useEffect( () => {
 		if ( modalVisible ) {
@@ -196,6 +197,14 @@ const Campaigns = props => {
 
 	return (
 		<Fragment>
+			{ hasPublishedAboveHeader && (
+				<Notice className="newspack-campaigns__above-header-notice" status="warning" isDismissible={ false }>
+					{ __(
+						'This site has published above-header prompts. These appear at the very top of the page and push the rest of the content down as they load, which can lower your Cumulative Layout Shift (CLS) score. To reduce the impact, keep above-header prompts short, or use an overlay placement instead.',
+						'newspack-plugin'
+					) }
+				</Notice>
+			) }
 			<Card headerActions noBorder>
 				<div className="newspack-campaigns__campaign-group__filter-group-actions">
 					<CustomSelectControl
diff --git a/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/style.scss b/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/style.scss
index 374948a07f..b1736f5915 100644
--- a/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/style.scss
+++ b/plugins/newspack-plugin/src/wizards/audience/views/campaigns/campaigns/style.scss
@@ -65,6 +65,10 @@
 	}
 }
 
+.newspack-campaigns__above-header-notice {
+	margin-bottom: 16px;
+}
+
 .newspack-card__buttons-prompt {
 	.newspack-button {
 		color: wp-colors.$gray-900;
diff --git a/plugins/newspack-plugin/tests/mocks/newspack-popups-model-mock.php b/plugins/newspack-plugin/tests/mocks/newspack-popups-model-mock.php
new file mode 100644
index 0000000000..6733944482
--- /dev/null
+++ b/plugins/newspack-plugin/tests/mocks/newspack-popups-model-mock.php
@@ -0,0 +1,35 @@
+<?php // phpcs:disable WordPress.Files.FileName.InvalidClassFileName
+/**
+ * Newspack_Popups_Model stub for tests.
+ *
+ * The Perfmatters integration calls
+ * \Newspack_Popups_Model::has_published_above_header_prompts() guarded by
+ * method_exists(). newspack-popups is not loaded in this test suite, so this stub
+ * stands in for it and its return value is toggled via
+ * `Newspack_Popups_Model::$has_above_header`.
+ *
+ * @package Newspack\Tests
+ */
+
+if ( ! class_exists( 'Newspack_Popups_Model' ) ) {
+	/**
+	 * Minimal Newspack_Popups_Model stub. Only the surface the integration touches.
+	 */
+	class Newspack_Popups_Model {
+		/**
+		 * Stubbed detection result.
+		 *
+		 * @var bool
+		 */
+		public static $has_above_header = false;
+
+		/**
+		 * Stubbed detection method.
+		 *
+		 * @return bool
+		 */
+		public static function has_published_above_header_prompts() {
+			return self::$has_above_header;
+		}
+	}
+}
diff --git a/plugins/newspack-plugin/tests/unit-tests/perfmatters.php b/plugins/newspack-plugin/tests/unit-tests/perfmatters.php
index ec2d830479..4f8bce6082 100644
--- a/plugins/newspack-plugin/tests/unit-tests/perfmatters.php
+++ b/plugins/newspack-plugin/tests/unit-tests/perfmatters.php
@@ -1,32 +1,127 @@
 <?php
 /**
- * Tests for the Perfmatters integration WooCommerce veto.
+ * Tests the Perfmatters integration (NPPM-2934).
  *
- * @package Newspack
+ * @package Newspack\Tests
  */
 
 use Newspack\Perfmatters;
 use Newspack\WooCommerce_Content_Detector;
 
+require_once __DIR__ . '/../mocks/newspack-popups-model-mock.php';
+
 /**
- * Test the perfmatters_disable_woocommerce_scripts callback.
+ * Tests the Perfmatters integration: above-header prompt handling and the
+ * WooCommerce veto.
  */
 class Newspack_Test_Perfmatters extends WP_UnitTestCase {
-
 	/**
 	 * Reset the detector memo before each test.
 	 */
-	public function setUp(): void {
-		parent::setUp();
+	public function set_up() {
+		parent::set_up();
 		WooCommerce_Content_Detector::reset_memo();
 	}
 
 	/**
-	 * Reset the detector memo after each test.
+	 * Reset the above-header flag and the detector memo after each test.
 	 */
-	public function tearDown(): void {
+	public function tear_down() {
+		\Newspack_Popups_Model::$has_above_header = false;
 		WooCommerce_Content_Detector::reset_memo();
-		parent::tearDown();
+		parent::tear_down();
+	}
+
+	/**
+	 * Without above-header prompts, the prompt reveal scripts stay in the JS delay queue.
+	 */
+	public function test_reveal_scripts_delayed_without_above_header_prompts() {
+		\Newspack_Popups_Model::$has_above_header = false;
+
+		$options = Perfmatters::set_defaults( [] );
+
+		$this->assertContains( 'newspack-popups', $options['assets']['delay_js_inclusions'] );
+		$this->assertContains( 'window.newspack', $options['assets']['delay_js_inclusions'] );
+		$this->assertNotContains( 'newspack-popups', $options['assets']['js_exclusions'] );
+		$this->assertNotContains( 'newspack-plugin', $options['assets']['js_exclusions'] );
+	}
+
+	/**
+	 * With published above-header prompts, the reveal scripts are removed from the JS
+	 * delay queue and excluded from deferral so the prompts appear immediately.
+	 */
+	public function test_reveal_scripts_undelayed_with_above_header_prompts() {
+		\Newspack_Popups_Model::$has_above_header = true;
+
+		$options = Perfmatters::set_defaults( [] );
+
+		$this->assertNotContains( 'newspack-popups', $options['assets']['delay_js_inclusions'] );
+		$this->assertNotContains( 'window.newspack', $options['assets']['delay_js_inclusions'] );
+		$this->assertNotContains( 'newspack-plugin', $options['assets']['delay_js_inclusions'] );
+
+		$this->assertContains( 'newspack-popups', $options['assets']['js_exclusions'] );
+		$this->assertContains( 'newspack-plugin', $options['assets']['js_exclusions'] );
+
+		// `window.newspack` is an inline token; deferral only applies to external <script src>
+		// files, so it is intentionally kept out of the defer exclusions even while present in
+		// the delay exclusions. Assert the asymmetry so the two lists cannot silently drift.
+		$this->assertNotContains( 'window.newspack', $options['assets']['js_exclusions'] );
+	}
+
+	/**
+	 * Perfmatters persists its delay list whenever its settings are saved through the UI,
+	 * so on a configured site the stored option already contains the reveal scripts. They
+	 * must be subtracted from the merged list, not merely omitted from Newspack's own
+	 * contribution – otherwise the merge puts them back and the prompts stay delayed on
+	 * exactly the sites this targets.
+	 */
+	public function test_reveal_scripts_undelayed_when_already_in_saved_option() {
+		\Newspack_Popups_Model::$has_above_header = true;
+
+		$options = Perfmatters::set_defaults(
+			[
+				'assets' => [
+					'delay_js_inclusions' => [ 'newspack-popups', 'window.newspack', 'newspack-plugin', 'publisher-script' ],
+				],
+			]
+		);
+
+		$this->assertNotContains( 'newspack-popups', $options['assets']['delay_js_inclusions'] );
+		$this->assertNotContains( 'window.newspack', $options['assets']['delay_js_inclusions'] );
+		$this->assertNotContains( 'newspack-plugin', $options['assets']['delay_js_inclusions'] );
+
+		// The publisher's own entries survive.
+		$this->assertContains( 'publisher-script', $options['assets']['delay_js_inclusions'] );
+	}
+
+	/**
+	 * Without above-header prompts, a saved delay list keeps the reveal scripts.
+	 */
+	public function test_saved_delay_list_is_preserved_without_above_header_prompts() {
+		\Newspack_Popups_Model::$has_above_header = false;
+
+		$options = Perfmatters::set_defaults(
+			[
+				'assets' => [
+					'delay_js_inclusions' => [ 'newspack-popups', 'publisher-script' ],
+				],
+			]
+		);
+
+		$this->assertContains( 'newspack-popups', $options['assets']['delay_js_inclusions'] );
+		$this->assertContains( 'publisher-script', $options['assets']['delay_js_inclusions'] );
+	}
+
+	/**
+	 * Unrelated scripts remain delayed regardless of above-header prompts.
+	 */
+	public function test_other_scripts_still_delayed_with_above_header_prompts() {
+		\Newspack_Popups_Model::$has_above_header = true;
+
+		$options = Perfmatters::set_defaults( [] );
+
+		$this->assertContains( 'newspack-blocks', $options['assets']['delay_js_inclusions'] );
+		$this->assertContains( 'recaptcha', $options['assets']['delay_js_inclusions'] );
 	}
 
 	/**
diff --git a/plugins/newspack-popups/includes/class-newspack-popups-model.php b/plugins/newspack-popups/includes/class-newspack-popups-model.php
index bae0a5143a..2f715b6dec 100644
--- a/plugins/newspack-popups/includes/class-newspack-popups-model.php
+++ b/plugins/newspack-popups/includes/class-newspack-popups-model.php
@@ -11,6 +11,28 @@
  * API endpoints
  */
 final class Newspack_Popups_Model {
+	/**
+	 * Transient key caching whether the site has any published above-header prompts.
+	 *
+	 * @var string
+	 */
+	const HAS_ABOVE_HEADER_TRANSIENT = 'newspack_popups_has_above_header';
+
+	/**
+	 * Request-level memo of has_published_above_header_prompts(). Null when unresolved.
+	 *
+	 * @var bool|null
+	 */
+	private static $has_above_header_memo = null;
+
+	/**
+	 * Whether has_published_above_header_prompts() is mid-resolution, to catch a nested
+	 * read triggered from within its own query.
+	 *
+	 * @var bool
+	 */
+	private static $is_resolving_above_header = false;
+
 	/**
 	 * Possible placements of overlay popups.
 	 *
@@ -854,6 +876,100 @@ public static function is_above_header( $popup ) {
 		return 'above_header' === $popup['options']['placement'];
 	}
 
+	/**
+	 * Whether the site has at least one published above-header prompt.
+	 *
+	 * Detection is intentionally coarse: it keys only on post status (`publish`) and
+	 * placement (`above_header`), not on full display eligibility (active campaign
+	 * group, activation/deactivation window, segment match). Evaluating real display
+	 * eligibility would duplicate the Inserter's per-request logic and is too expensive
+	 * for this path, which the Perfmatters integration reads on essentially every
+	 * front-end request. The trade-off is deliberate and fail-safe: a published
+	 * above-header prompt that never actually renders (parked in an inactive campaign,
+	 * expired, or behind a non-matching segment) will keep the reveal-path scripts out
+	 * of Perfmatters' JS delay/defer queues site-wide, forfeiting that optimization
+	 * until the prompt is unpublished or deleted. Nothing breaks – it only loses a
+	 * performance win – so over-counting is preferred to a delayed (invisible) prompt.
+	 *
+	 * The result is cached in a transient flushed via flush_above_header_cache()
+	 * whenever a prompt is saved, has its status transitioned, has its `placement` meta
+	 * changed, or is deleted (see Newspack_Popups). The transient flush is immediate, but
+	 * on a cached page (batcache / Perfmatters page cache) the script-loading change only
+	 * takes effect once that page's own cache entry is purged or expires. Publishing a
+	 * prompt purges the prompt's own URL, not necessarily the article/home pages where
+	 * the reveal scripts actually matter, so already-cached pages keep the old behavior
+	 * until their cache entries turn over.
+	 *
+	 * On top of the transient, the result is memoized for the rest of the request. The
+	 * Perfmatters integration reads it from `option_perfmatters_options`, which fires on
+	 * every read of that option and Perfmatters reads it many times per request; without
+	 * the memo each of those repeats the transient lookup (an uncached options query on
+	 * sites with no persistent object cache). The memo is reset by
+	 * flush_above_header_cache(), so an in-request change is still picked up.
+	 *
+	 * @return boolean True if at least one published above-header prompt exists.
+	 */
+	public static function has_published_above_header_prompts() {
+		if ( null !== self::$has_above_header_memo ) {
+			return self::$has_above_header_memo;
+		}
+
+		// The WP_Query below runs inside the option_perfmatters_options filter on a
+		// transient miss. Anything it touches that reads perfmatters_options again would
+		// re-enter this method, and with nothing memoized yet would start the query over,
+		// recursing without end. Report "no prompts" to such a nested read - it resolves
+		// before the outer pass has an answer to give it - and let the outer pass memoize
+		// the real result.
+		if ( self::$is_resolving_above_header ) {
+			return false;
+		}
+		self::$is_resolving_above_header = true;
+
+		// Reset the recursion guard unconditionally: if get_transient() or the WP_Query
+		// throws (or a hook firing inside them does), leaving the guard set would make every
+		// later call this request short-circuit to false, silently re-delaying the reveal
+		// scripts - the exact symptom this path fixes.
+		try {
+			$cached = get_transient( self::HAS_ABOVE_HEADER_TRANSIENT );
+			if ( false !== $cached ) {
+				self::$has_above_header_memo = '1' === $cached;
+				return self::$has_above_header_memo;
+			}
+
+			$query = new WP_Query(
+				[
+					'post_type'              => Newspack_Popups::NEWSPACK_POPUPS_CPT,
+					'post_status'            => 'publish',
+					'posts_per_page'         => 1,
+					'fields'                 => 'ids',
+					'no_found_rows'          => true,
+					'update_post_meta_cache' => false,
+					'update_post_term_cache' => false,
+					'orderby'                => 'none', // Pure existence check - skip the default post_date filesort.
+					'meta_key'               => 'placement', // phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_meta_key
+					'meta_value'             => 'above_header', // phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_meta_value
+				]
+			);
+			$has_above_header = $query->have_posts();
+
+			set_transient( self::HAS_ABOVE_HEADER_TRANSIENT, $has_above_header ? '1' : '0', DAY_IN_SECONDS );
+
+			self::$has_above_header_memo = $has_above_header;
+
+			return $has_above_header;
+		} finally {
+			self::$is_resolving_above_header = false;
+		}
+	}
+
+	/**
+	 * Flush the cached above-header prompt detection.
+	 */
+	public static function flush_above_header_cache() {
+		self::$has_above_header_memo = null;
+		delete_transient( self::HAS_ABOVE_HEADER_TRANSIENT );
+	}
+
 	/**
 	 * Does the popup have newsletter prompt?
 	 *
diff --git a/plugins/newspack-popups/includes/class-newspack-popups.php b/plugins/newspack-popups/includes/class-newspack-popups.php
index ef146d8be0..5313feba53 100644
--- a/plugins/newspack-popups/includes/class-newspack-popups.php
+++ b/plugins/newspack-popups/includes/class-newspack-popups.php
@@ -93,8 +93,14 @@ public function __construct() {
 		add_action( 'add_meta_boxes_' . self::NEWSPACK_POPUPS_CPT, [ __CLASS__, 'remove_custom_fields_meta_box' ], 99 );
 		add_filter( 'display_post_states', [ __CLASS__, 'display_post_states' ], 10, 2 );
 		add_action( 'save_post_' . self::NEWSPACK_POPUPS_CPT, [ __CLASS__, 'popup_default_fields' ], 10, 3 );
+		add_action( 'save_post_' . self::NEWSPACK_POPUPS_CPT, [ 'Newspack_Popups_Model', 'flush_above_header_cache' ] );
 		add_action( 'transition_post_status', [ __CLASS__, 'prevent_default_category_on_publish' ], 10, 3 );
 		add_action( 'transition_post_status', [ __CLASS__, 'store_activation_dates' ], 10, 3 );
+		add_action( 'transition_post_status', [ __CLASS__, 'flush_above_header_cache_on_transition' ], 10, 3 );
+		add_action( 'before_delete_post', [ __CLASS__, 'flush_above_header_cache_on_delete' ], 10, 2 );
+		add_action( 'added_post_meta', [ __CLASS__, 'flush_above_header_cache_on_meta' ], 10, 3 );
+		add_action( 'updated_post_meta', [ __CLASS__, 'flush_above_header_cache_on_meta' ], 10, 3 );
+		add_action( 'deleted_post_meta', [ __CLASS__, 'flush_above_header_cache_on_meta' ], 10, 3 );
 		add_action( 'pre_delete_term', [ __CLASS__, 'prevent_default_category_on_term_delete' ], 10, 2 );
 		add_filter( 'show_admin_bar', [ __CLASS__, 'show_admin_bar' ], 10, 2 ); // phpcs:ignore WordPressVIPMinimum.UserExperience.AdminBarRemoval.RemovalDetected
 		add_filter( 'newspack_blocks_should_deduplicate', [ __CLASS__, 'newspack_blocks_should_deduplicate' ], 10, 2 );
@@ -1200,6 +1206,51 @@ public static function store_activation_dates( $new_status, $old_status, $post )
 		}
 	}
 
+	/**
+	 * Flush the above-header prompt detection cache when a prompt's status changes.
+	 *
+	 * @param string  $new_status New status.
+	 * @param string  $old_status Old status.
+	 * @param WP_Post $post       Post.
+	 */
+	public static function flush_above_header_cache_on_transition( $new_status, $old_status, $post ) {
+		if ( self::NEWSPACK_POPUPS_CPT === $post->post_type ) {
+			Newspack_Popups_Model::flush_above_header_cache();
+		}
+	}
+
+	/**
+	 * Flush the above-header prompt detection cache when a prompt is permanently deleted.
+	 *
+	 * @param int          $post_id Post ID.
+	 * @param WP_Post|null $post    Post object.
+	 */
+	public static function flush_above_header_cache_on_delete( $post_id, $post = null ) {
+		$post_type = $post instanceof WP_Post ? $post->post_type : get_post_type( $post_id );
+		if ( self::NEWSPACK_POPUPS_CPT === $post_type ) {
+			Newspack_Popups_Model::flush_above_header_cache();
+		}
+	}
+
+	/**
+	 * Flush the above-header prompt detection cache when a prompt's placement meta
+	 * changes outside of a post save (e.g. a CLI/importer/programmatic meta update).
+	 *
+	 * Shared handler for added_post_meta / updated_post_meta / deleted_post_meta, whose
+	 * second and third arguments are the object ID and meta key in every case. WordPress
+	 * offers no post-type-scoped variant of these hooks, so the post type is checked here;
+	 * the meta key is compared first to keep that check off the path of unrelated writes.
+	 *
+	 * @param int|int[] $meta_id   Meta ID (or IDs, for deleted_post_meta). Unused.
+	 * @param int       $object_id Post ID the meta belongs to.
+	 * @param string    $meta_key  Meta key being changed.
+	 */
+	public static function flush_above_header_cache_on_meta( $meta_id, $object_id, $meta_key ) {
+		if ( 'placement' === $meta_key && self::NEWSPACK_POPUPS_CPT === get_post_type( $object_id ) ) {
+			Newspack_Popups_Model::flush_above_header_cache();
+		}
+	}
+
 	/**
 	 * When a category is deleted, any posts that have only that category assigned
 	 * are automatically assigned the site's default category (usually "Uncategorized").
diff --git a/plugins/newspack-popups/src/editor/index.js b/plugins/newspack-popups/src/editor/index.js
index 9ea6744dd6..a1001718bb 100644
--- a/plugins/newspack-popups/src/editor/index.js
+++ b/plugins/newspack-popups/src/editor/index.js
@@ -151,6 +151,32 @@ registerPlugin( 'newspack-popups-editor', {
 	icon: null,
 } );
 
+// Show a CLS warning above the editor while an above-header placement is selected.
+registerPlugin( 'newspack-popups-above-header-notice', {
+	render: function AboveHeaderNotice() {
+		const { createNotice, removeNotice } = useDispatch( 'core/notices' );
+		const placement = useSelect( select => select( 'core/editor' ).getEditedPostAttribute( 'meta' )?.placement );
+		useEffect( () => {
+			const noticeId = 'newspack-popups__above-header-cls';
+			if ( 'above_header' === placement ) {
+				createNotice(
+					'warning',
+					__(
+						'Above-header prompts appear at the very top of the page and push the rest of the content down as they load, which can lower your Cumulative Layout Shift (CLS) score. To reduce the impact, keep the prompt short, or use an overlay placement instead.',
+						'newspack-popups'
+					),
+					{ id: noticeId, isDismissible: false }
+				);
+			}
+			// The cleanup removes the notice on unmount and before every placement
+			// change, so a non-above-header placement leaves no notice behind.
+			return () => removeNotice( noticeId );
+		}, [ placement ] );
+		return null;
+	},
+	icon: null,
+} );
+
 // Hide Newspack's Homepage Posts block deduplication toggle when the popup is an overlay.
 registerPlugin( 'newspack-popups-disable-newspack-blocks-deduplication', {
 	render: function HideDeduplicationToggle() {
diff --git a/plugins/newspack-popups/tests/test-above-header-detection.php b/plugins/newspack-popups/tests/test-above-header-detection.php
new file mode 100644
index 0000000000..d31e536ac2
--- /dev/null
+++ b/plugins/newspack-popups/tests/test-above-header-detection.php
@@ -0,0 +1,147 @@
+<?php
+/**
+ * Tests for above-header prompt detection (NPPM-2934).
+ *
+ * @package Newspack_Popups
+ */
+
+/**
+ * Above-header prompt detection test case.
+ */
+class AboveHeaderDetectionTest extends WP_UnitTestCase {
+	public function set_up() { // phpcs:ignore Squiz.Commenting.FunctionComment.Missing
+		parent::set_up();
+		// Clear any value cached by a previous test (transients survive the DB
+		// transaction rollback when a persistent object cache is in use).
+		Newspack_Popups_Model::flush_above_header_cache();
+	}
+
+	public function tear_down() { // phpcs:ignore Squiz.Commenting.FunctionComment.Missing
+		Newspack_Popups_Model::flush_above_header_cache();
+		parent::tear_down();
+	}
+
+	/**
+	 * Create a prompt with a given placement and status.
+	 *
+	 * Deliberately does NOT flush the detection cache: the production invalidation
+	 * hooks (save_post, placement-meta writes) must do that, so the cache-invalidation
+	 * tests actually exercise them rather than a test-only flush.
+	 *
+	 * @param string $placement Placement meta value.
+	 * @param string $status    Post status.
+	 * @return int Prompt ID.
+	 */
+	private function create_prompt( $placement, $status = 'publish' ) {
+		$prompt_id = self::factory()->post->create(
+			[
+				'post_type'   => Newspack_Popups::NEWSPACK_POPUPS_CPT,
+				'post_title'  => 'A prompt',
+				'post_status' => $status,
+			]
+		);
+		update_post_meta( $prompt_id, 'placement', $placement );
+		return $prompt_id;
+	}
+
+	/**
+	 * With no prompts, there are no published above-header prompts.
+	 */
+	public function test_returns_false_without_prompts() {
+		$this->assertFalse( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+
+	/**
+	 * A published above-header prompt is detected.
+	 */
+	public function test_detects_published_above_header_prompt() {
+		$this->create_prompt( 'above_header', 'publish' );
+		$this->assertTrue( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+
+	/**
+	 * A draft above-header prompt is not counted.
+	 */
+	public function test_ignores_unpublished_above_header_prompt() {
+		$this->create_prompt( 'above_header', 'draft' );
+		$this->assertFalse( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+
+	/**
+	 * A published prompt with a different placement is not counted.
+	 */
+	public function test_ignores_non_above_header_prompt() {
+		$this->create_prompt( 'inline', 'publish' );
+		$this->assertFalse( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+
+	/**
+	 * Publishing an above-header prompt invalidates a cached "false" result so the
+	 * Perfmatters integration picks up the change without waiting for the TTL. No manual
+	 * flush here – the production invalidation hooks (save_post and the placement-meta
+	 * write) must do it.
+	 */
+	public function test_publishing_prompt_invalidates_cache() {
+		// Prime the cache with a negative result.
+		$this->assertFalse( Newspack_Popups_Model::has_published_above_header_prompts() );
+
+		$this->create_prompt( 'above_header', 'publish' );
+
+		$this->assertTrue( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+
+	/**
+	 * Trashing the only above-header prompt invalidates the cached "true" result via
+	 * the transition_post_status hook.
+	 */
+	public function test_trashing_prompt_invalidates_cache() {
+		$prompt_id = $this->create_prompt( 'above_header', 'publish' );
+		$this->assertTrue( Newspack_Popups_Model::has_published_above_header_prompts() );
+
+		wp_trash_post( $prompt_id );
+
+		$this->assertFalse( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+
+	/**
+	 * Permanently deleting the only above-header prompt invalidates the cache. This
+	 * covers the force-delete path that transition_post_status does not (handled by the
+	 * before_delete_post hook).
+	 */
+	public function test_force_deleting_prompt_invalidates_cache() {
+		$prompt_id = $this->create_prompt( 'above_header', 'publish' );
+		$this->assertTrue( Newspack_Popups_Model::has_published_above_header_prompts() );
+
+		wp_delete_post( $prompt_id, true );
+
+		$this->assertFalse( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+
+	/**
+	 * The Perfmatters integration reads this on every get_option( 'perfmatters_options' ),
+	 * many times per request, so the result is memoized for the request: a repeat call
+	 * must not hit the database at all.
+	 */
+	public function test_result_is_memoized_within_the_request() {
+		$this->create_prompt( 'above_header', 'publish' );
+		$this->assertTrue( Newspack_Popups_Model::has_published_above_header_prompts() );
+
+		$queries_after_first_call = get_num_queries();
+		Newspack_Popups_Model::has_published_above_header_prompts();
+
+		$this->assertSame( $queries_after_first_call, get_num_queries() );
+	}
+
+	/**
+	 * Changing a published prompt's placement away from above_header invalidates the
+	 * cache via the placement-meta hook, even without a post save.
+	 */
+	public function test_changing_placement_away_invalidates_cache() {
+		$prompt_id = $this->create_prompt( 'above_header', 'publish' );
+		$this->assertTrue( Newspack_Popups_Model::has_published_above_header_prompts() );
+
+		update_post_meta( $prompt_id, 'placement', 'inline' );
+
+		$this->assertFalse( Newspack_Popups_Model::has_published_above_header_prompts() );
+	}
+}