diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index eceab341255..83369724635 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -93,6 +93,7 @@
 #include "storage/reinit.h"
 #include "storage/spin.h"
 #include "storage/sync.h"
+#include "storage/condition_variable.h"
 #include "utils/guc_hooks.h"
 #include "utils/guc_tables.h"
 #include "utils/injection_point.h"
@@ -137,6 +138,8 @@ int			max_slot_wal_keep_size_mb = -1;
 int			wal_decode_buffer_size = 512 * 1024;
 bool		track_wal_io_timing = false;
 
+extern ConditionVariable WalReadersConditionVariable;
+
 #ifdef WAL_DEBUG
 bool		XLOG_DEBUG = false;
 #endif
@@ -2912,6 +2915,9 @@ XLogFlush(XLogRecPtr record)
 	/* wake up walsenders now that we've released heavily contended locks */
 	WalSndWakeupProcessRequests(true, !RecoveryInProgress());
 
+    /* wake up WAL readers waiting for new WAL */
+    ConditionVariableBroadcast(&WalReadersConditionVariable);
+
 	/*
 	 * If we still haven't flushed to the request point then we have a
 	 * problem; most likely, the requested flush point is past end of XLOG.
@@ -4981,7 +4987,7 @@ XLOGShmemInit(void)
 	}
 #endif
 
-
+    ConditionVariableInit(&WalReadersConditionVariable);
 	XLogCtl = (XLogCtlData *)
 		ShmemInitStruct("XLOG Ctl", XLOGShmemSize(), &foundXLog);
 
diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c
index 3e3c4da01a2..214e4e700da 100644
--- a/src/backend/access/transam/xlogrecovery.c
+++ b/src/backend/access/transam/xlogrecovery.c
@@ -1984,6 +1984,10 @@ ApplyWalRecord(XLogReaderState *xlogreader, XLogRecord *record, TimeLineID *repl
 	XLogRecoveryCtl->replayEndTLI = *replayTLI;
 	SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
+    extern ConditionVariable WalReadersConditionVariable;
+    /* Signal WAL readers that recovery has advanced */
+    ConditionVariableBroadcast(&WalReadersConditionVariable);
+
 	/*
 	 * If we are attempting to enter Hot Standby mode, process XIDs we see
 	 */
diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c
index 38176d9688e..2ff5feca441 100644
--- a/src/backend/access/transam/xlogutils.c
+++ b/src/backend/access/transam/xlogutils.c
@@ -23,12 +23,13 @@
 #include "access/xlogrecovery.h"
 #include "access/xlog_internal.h"
 #include "access/xlogutils.h"
+#include "storage/condition_variable.h"
 #include "miscadmin.h"
 #include "storage/fd.h"
 #include "storage/smgr.h"
 #include "utils/hsearch.h"
 #include "utils/rel.h"
-
+#include "utils/wait_event_types.h"
 
 /* GUC variable */
 bool		ignore_invalid_pages = false;
@@ -52,6 +53,9 @@ bool		InRecovery = false;
 /* Are we in Hot Standby mode? Only valid in startup process, see xlogutils.h */
 HotStandbyState standbyState = STANDBY_DISABLED;
 
+/* Global condition variable for WAL readers */
+ConditionVariable WalReadersConditionVariable = {0};
+
 /*
  * During XLOG replay, we may see XLOG records for incremental updates of
  * pages that no longer exist, because their relation was later dropped or
@@ -845,6 +849,8 @@ int
 read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
 					 int reqLen, XLogRecPtr targetRecPtr, char *cur_page)
 {
+    ereport(LOG, (errmsg("OLD_FUNC: read_local_xlog_page_guts called")));
+
 	return read_local_xlog_page_guts(state, targetPagePtr, reqLen,
 									 targetRecPtr, cur_page, true);
 }
@@ -869,7 +875,7 @@ static int
 read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
 						  int reqLen, XLogRecPtr targetRecPtr,
 						  char *cur_page, bool wait_for_wal)
-{
+{ 
 	XLogRecPtr	read_upto,
 				loc;
 	TimeLineID	tli;
@@ -877,7 +883,10 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
 	WALReadError errinfo;
 	TimeLineID	currTLI;
 
-	loc = targetPagePtr + reqLen;
+    ereport(LOG, (errmsg("WAL READER DEBUG: read_local_xlog_page_guts CALLED")));
+    ereport(LOG, (errmsg("targetPagePtr wait_for_wal=%d", wait_for_wal))); 
+
+    loc = targetPagePtr + reqLen;
 
 	/*
 	 * Loop waiting for xlog to be available if necessary
@@ -899,6 +908,8 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
 			read_upto = GetXLogReplayRecPtr(&currTLI);
 		tli = currTLI;
 
+        ereport(LOG, (errmsg("DEBUG: currTLI=%u, state->currTLI=%u", currTLI, state->currTLI)));
+
 		/*
 		 * Check which timeline to get the record from.
 		 *
@@ -928,14 +939,18 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
 		if (state->currTLI == currTLI)
 		{
 
-			if (loc <= read_upto)
-				break;
+			if (loc <= read_upto) 
+            {
+                ereport(LOG, (errmsg("DEBUG: currTLI=%u, state->currTLI=%u", currTLI, state->currTLI))); 
+    			break;
+            }
 
 			/* If asked, let's not wait for future WAL. */
 			if (!wait_for_wal)
 			{
 				ReadLocalXLogPageNoWaitPrivate *private_data;
 
+                ereport(LOG, (errmsg("DEBUG: Breaking loop - WAL available")));
 				/*
 				 * Inform the caller of read_local_xlog_page_no_wait that the
 				 * end of WAL has been reached.
@@ -947,8 +962,15 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
 			}
 
 			CHECK_FOR_INTERRUPTS();
-			pg_usleep(1000L);
-		}
+
+            ereport(LOG, (errmsg("DEBUG: About to wait for WAL - NEED LSN %X/%X, HAVE %X/%X", 
+                (uint32)(loc >> 32), (uint32)loc,
+                (uint32)(read_upto >> 32), (uint32)read_upto)));  
+
+            /* Replace pg_usleep with condition variable wait */
+            ConditionVariableSleep(&WalReadersConditionVariable, WAIT_EVENT_WAL_READ);
+            ereport(LOG, (errmsg("DEBUG: Returned from ConditionVariableSleep")));
+        }
 		else
 		{
 			/*
@@ -959,6 +981,7 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
 			 * about the new timeline, so we must've received past the end of
 			 * it.
 			 */
+            elog(LOG, "DEBUG: WAL NOT available - loc > read_upto, should wait");
 			read_upto = state->currTLIValidUntil;
 
 			/*
@@ -976,6 +999,10 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
 		}
 	}
 
+    /* Wake up after the loop if we used condition variable */
+    if (wait_for_wal && state->currTLI == currTLI)
+        ConditionVariableCancelSleep();
+
 	if (targetPagePtr + XLOG_BLCKSZ <= read_upto)
 	{
 		/*
diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
index 93ed2eb368e..c335fe3f7ed 100644
--- a/src/backend/replication/logical/logical.c
+++ b/src/backend/replication/logical/logical.c
@@ -30,7 +30,9 @@
 
 #include "access/xact.h"
 #include "access/xlog_internal.h"
+#include "access/xlog.h"
 #include "access/xlogutils.h"
+#include "access/xlog_internal.h"
 #include "fmgr.h"
 #include "miscadmin.h"
 #include "pgstat.h"
@@ -41,6 +43,8 @@
 #include "replication/snapbuild.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
+#include "storage/condition_variable.h"
+#include "utils/wait_event_types.h"
 #include "utils/builtins.h"
 #include "utils/injection_point.h"
 #include "utils/inval.h"
@@ -103,6 +107,91 @@ static void update_progress_txn_cb_wrapper(ReorderBuffer *cache,
 
 static void LoadOutputPlugin(OutputPluginCallbacks *callbacks, const char *plugin);
 
+/* Condition variable */
+extern ConditionVariable WalReadersConditionVariable;
+
+/*
+ * Wait for WAL to be available for logical decoding.
+ * 
+ * This function efficiently waits until the specified target LSN is available
+ * in WAL, using condition variables instead of the polling approach used in
+ * read_local_xlog_page_guts. The condition variable is signaled whenever new
+ * WAL is flushed (by XLogFlush) or replayed (during recovery by ApplyWalRecord),
+ * allowing logical decoding to wake up immediately when new data is available
+ * rather than polling repeatedly.
+ */
+XLogRecPtr
+LogicalWaitForWal(XLogRecPtr targetLSN)
+{
+    XLogRecPtr  flushptr;
+   
+    for (;;)
+    {
+        CHECK_FOR_INTERRUPTS();
+        
+        /* Get the current flush/replay position */
+        if (!RecoveryInProgress())
+            flushptr = GetFlushRecPtr(NULL);
+        else
+            flushptr = GetXLogReplayRecPtr(NULL);
+       
+        /* If we have enough WAL, break out of the loop */
+        if (targetLSN <= flushptr)
+            break;
+
+        ConditionVariableSleep(&WalReadersConditionVariable, WAIT_EVENT_WAL_READ);
+    }
+    
+    /* Cancel the sleep to clean up */
+    ConditionVariableCancelSleep();
+
+    return flushptr;
+}
+
+/*
+ * XLogReaderRoutine->page_read callback for logical decoding contexts
+ * that uses condition variables for efficient waiting
+ */
+int
+logical_read_xlog_page_cv(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen,
+                          XLogRecPtr targetRecPtr, char *cur_page)
+{
+    XLogRecPtr  flushptr;
+    int         count;
+    WALReadError errinfo;
+    TimeLineID  tli;
+
+    XLogRecPtr test_flushptr = LogicalWaitForWal(targetPagePtr + reqLen);
+    (void)test_flushptr;  /* Use the result to prevent optimization */  
+
+    flushptr = LogicalWaitForWal(targetPagePtr + reqLen);
+
+    if (flushptr < targetPagePtr + reqLen)
+        return -1;
+    
+    if (RecoveryInProgress())
+        GetXLogReplayRecPtr(&tli);
+    else
+        tli = GetWALInsertionTimeLine();
+    
+    XLogReadDetermineTimeline(state, targetPagePtr, reqLen, tli);
+    
+    if (targetPagePtr + XLOG_BLCKSZ <= flushptr)
+        count = XLOG_BLCKSZ;
+    else if (targetPagePtr + reqLen > flushptr)
+        return -1;
+    else
+        count = flushptr - targetPagePtr;
+    
+    if (!WALRead(state, cur_page, targetPagePtr, count, tli, &errinfo))
+        WALReadRaiseError(&errinfo);
+    
+    /* Remove the XLByteToSeg and CheckXLogRemoved calls for now */
+    /* They are safety checks that might be handled at a higher level */
+    
+    return count;
+}
+
 /*
  * Make sure the current settings & environment are capable of doing logical
  * decoding.
@@ -2018,7 +2107,7 @@ LogicalReplicationSlotHasPendingWal(XLogRecPtr end_of_wal)
 		ctx = CreateDecodingContext(InvalidXLogRecPtr,
 									NIL,
 									true,	/* fast_forward */
-									XL_ROUTINE(.page_read = read_local_xlog_page,
+									XL_ROUTINE(.page_read = logical_read_xlog_page_cv,
 											   .segment_open = wal_segment_open,
 											   .segment_close = wal_segment_close),
 									NULL, NULL, NULL);
@@ -2088,7 +2177,7 @@ LogicalSlotAdvanceAndCheckSnapState(XLogRecPtr moveto,
 	LogicalDecodingContext *ctx;
 	ResourceOwner old_resowner PG_USED_FOR_ASSERTS_ONLY = CurrentResourceOwner;
 	XLogRecPtr	retlsn;
-
+ 
 	Assert(moveto != InvalidXLogRecPtr);
 
 	if (found_consistent_snapshot)
@@ -2104,7 +2193,7 @@ LogicalSlotAdvanceAndCheckSnapState(XLogRecPtr moveto,
 		ctx = CreateDecodingContext(InvalidXLogRecPtr,
 									NIL,
 									true,	/* fast_forward */
-									XL_ROUTINE(.page_read = read_local_xlog_page,
+									XL_ROUTINE(.page_read = logical_read_xlog_page_cv,
 											   .segment_open = wal_segment_open,
 											   .segment_close = wal_segment_close),
 									NULL, NULL, NULL);
diff --git a/src/backend/replication/logical/logicalfuncs.c b/src/backend/replication/logical/logicalfuncs.c
index 25f890ddeed..4bb84c2e6b9 100644
--- a/src/backend/replication/logical/logicalfuncs.c
+++ b/src/backend/replication/logical/logicalfuncs.c
@@ -19,6 +19,8 @@
 
 #include "access/xlogrecovery.h"
 #include "access/xlogutils.h"
+#include "access/xlog_internal.h"
+#include "access/xlog.h"
 #include "catalog/pg_type.h"
 #include "fmgr.h"
 #include "funcapi.h"
@@ -28,6 +30,7 @@
 #include "replication/decode.h"
 #include "replication/logical.h"
 #include "replication/message.h"
+#include "utils/wait_event_types.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/inval.h"
@@ -205,7 +208,7 @@ pg_logical_slot_get_changes_guts(FunctionCallInfo fcinfo, bool confirm, bool bin
 		ctx = CreateDecodingContext(InvalidXLogRecPtr,
 									options,
 									false,
-									XL_ROUTINE(.page_read = read_local_xlog_page,
+									XL_ROUTINE(.page_read = logical_read_xlog_page_cv,
 											   .segment_open = wal_segment_open,
 											   .segment_close = wal_segment_close),
 									LogicalOutputPrepareWrite,
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index b8f21153e7b..db6f929440c 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -146,7 +146,7 @@ create_logical_replication_slot(char *name, char *plugin,
 	ctx = CreateInitDecodingContext(plugin, NIL,
 									false,	/* just catalogs is OK */
 									restart_lsn,
-									XL_ROUTINE(.page_read = read_local_xlog_page,
+									XL_ROUTINE(.page_read = logical_read_xlog_page_cv,
 											   .segment_open = wal_segment_open,
 											   .segment_close = wal_segment_close),
 									NULL, NULL, NULL);
diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h
index d12798be3d8..398ef9b19cf 100644
--- a/src/include/access/xlog.h
+++ b/src/include/access/xlog.h
@@ -17,7 +17,6 @@
 #include "lib/stringinfo.h"
 #include "nodes/pg_list.h"
 
-
 /* Sync methods */
 enum WalSyncMethod
 {
diff --git a/src/include/access/xlogreader.h b/src/include/access/xlogreader.h
index dfabbbd57d4..ec45bb3111c 100644
--- a/src/include/access/xlogreader.h
+++ b/src/include/access/xlogreader.h
@@ -215,7 +215,6 @@ struct XLogReaderState
 	/* Set when XLP_FIRST_IS_OVERWRITE_CONTRECORD is found */
 	XLogRecPtr	overwrittenRecPtr;
 
-
 	/* ----------------------------------------
 	 * Decoded representation of current record
 	 *
diff --git a/src/include/replication/logical.h b/src/include/replication/logical.h
index 2e562bee5a9..5fce75a8298 100644
--- a/src/include/replication/logical.h
+++ b/src/include/replication/logical.h
@@ -152,4 +152,12 @@ extern bool LogicalReplicationSlotHasPendingWal(XLogRecPtr end_of_wal);
 extern XLogRecPtr LogicalSlotAdvanceAndCheckSnapState(XLogRecPtr moveto,
 													  bool *found_consistent_snapshot);
 
+extern XLogRecPtr LogicalWaitForWal(XLogRecPtr targetLSN);
+
+extern int logical_read_xlog_page_cv(XLogReaderState *state, 
+                                     XLogRecPtr targetPagePtr, 
+                                     int reqLen,
+                                     XLogRecPtr targetRecPtr, 
+                                     char *cur_page);
+
 #endif
diff --git a/src/test/regress/expected/logical_cv_edge_case.out b/src/test/regress/expected/logical_cv_edge_case.out
new file mode 100644
index 00000000000..4ec8df18c28
--- /dev/null
+++ b/src/test/regress/expected/logical_cv_edge_case.out
@@ -0,0 +1,43 @@
+-- Create logical replication slot
+SELECT 'init' FROM pg_create_logical_replication_slot('regress_cv_test_slot', 'test_decoding');
+ ?column? 
+----------
+ init
+(1 row)
+
+-- Create test table
+CREATE TABLE regress_cv_test (id SERIAL, data TEXT);
+-- Test: Empty reads (no waiting should occur)
+SELECT count(*) FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL);
+ count 
+-------
+     2
+(1 row)
+
+-- Test: Reading from current position (no waiting)
+SELECT pg_current_wal_lsn() AS current_lsn \gset
+SELECT count(*) FROM pg_logical_slot_get_changes('regress_cv_test_slot', :'current_lsn', NULL);
+ count 
+-------
+     0
+(1 row)
+
+-- Insert some test data to see actual changes
+INSERT INTO regress_cv_test (data) VALUES ('test1'), ('test2');
+-- Test: Read the actual changes
+SELECT data FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL) 
+WHERE data LIKE '%test%';
+                                  data                                  
+------------------------------------------------------------------------
+ table public.regress_cv_test: INSERT: id[integer]:1 data[text]:'test1'
+ table public.regress_cv_test: INSERT: id[integer]:2 data[text]:'test2'
+(2 rows)
+
+-- Cleanup
+SELECT pg_drop_replication_slot('regress_cv_test_slot');
+ pg_drop_replication_slot 
+--------------------------
+ 
+(1 row)
+
+DROP TABLE regress_cv_test;
diff --git a/src/test/regress/expected/logical_cv_waiting.out b/src/test/regress/expected/logical_cv_waiting.out
new file mode 100644
index 00000000000..cc37ae5c51a
--- /dev/null
+++ b/src/test/regress/expected/logical_cv_waiting.out
@@ -0,0 +1,47 @@
+-- Create logical replication slot
+SELECT 'init' FROM pg_create_logical_replication_slot('regress_cv_test_slot', 'test_decoding');
+ ?column? 
+----------
+ init
+(1 row)
+
+-- Create test table
+CREATE TABLE regress_cv_test (id SERIAL, data TEXT);
+
+-- Test: Empty reads (no waiting should occur)
+SELECT count(*) FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL);
+ count 
+-------
+     0
+(1 row)
+
+-- Test: Reading from current position (no waiting)
+SELECT pg_current_wal_lsn() AS current_lsn \gset
+SELECT count(*) FROM pg_logical_slot_get_changes('regress_cv_test_slot', :'current_lsn', NULL);
+ count 
+-------
+     0
+(1 row)
+
+-- Insert some test data to see actual changes
+INSERT INTO regress_cv_test (data) VALUES ('test1'), ('test2');
+INSERT 0 2
+
+-- Test: Read the actual changes
+SELECT data FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL) 
+WHERE data LIKE '%test%';
+                                   data                                  
+------------------------------------------------------------------------
+ table public.regress_cv_test: INSERT: id[integer]:1 data[text]:'test1'
+ table public.regress_cv_test: INSERT: id[integer]:2 data[text]:'test2'
+(2 rows)
+
+-- Cleanup
+SELECT pg_drop_replication_slot('regress_cv_test_slot');
+ pg_drop_replication_slot 
+--------------------------
+ 
+(1 row)
+
+DROP TABLE regress_cv_test;
+DROP TABLE
diff --git a/src/test/regress/sql/logical_cv_edge_case.sql b/src/test/regress/sql/logical_cv_edge_case.sql
new file mode 100644
index 00000000000..b41a0508184
--- /dev/null
+++ b/src/test/regress/sql/logical_cv_edge_case.sql
@@ -0,0 +1,23 @@
+-- Create logical replication slot
+SELECT 'init' FROM pg_create_logical_replication_slot('regress_cv_test_slot', 'test_decoding');
+
+-- Create test table
+CREATE TABLE regress_cv_test (id SERIAL, data TEXT);
+
+-- Test: Empty reads (no waiting should occur)
+SELECT count(*) FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL);
+
+-- Test: Reading from current position (no waiting)
+SELECT pg_current_wal_lsn() AS current_lsn \gset
+SELECT count(*) FROM pg_logical_slot_get_changes('regress_cv_test_slot', :'current_lsn', NULL);
+
+-- Insert some test data to see actual changes
+INSERT INTO regress_cv_test (data) VALUES ('test1'), ('test2');
+
+-- Test: Read the actual changes
+SELECT data FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL) 
+WHERE data LIKE '%test%';
+
+-- Cleanup
+SELECT pg_drop_replication_slot('regress_cv_test_slot');
+DROP TABLE regress_cv_test;
diff --git a/src/test/regress/sql/logical_cv_waiting.sql b/src/test/regress/sql/logical_cv_waiting.sql
new file mode 100644
index 00000000000..1f39d250e44
--- /dev/null
+++ b/src/test/regress/sql/logical_cv_waiting.sql
@@ -0,0 +1,35 @@
+-- Test condition variable-based WAL waiting for logical decoding
+
+-- Setup: Create a logical replication slot
+SELECT 'init' FROM pg_create_logical_replication_slot('regress_cv_test_slot', 'test_decoding');
+
+-- Create test table
+CREATE TABLE regress_cv_test (id SERIAL PRIMARY KEY, data TEXT);
+
+-- Test 1: Basic functionality - insert and decode (should not wait)
+BEGIN;
+INSERT INTO regress_cv_test (data) VALUES ('test1');
+COMMIT;
+
+-- Verify we can read the changes
+SELECT data FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL) 
+WHERE data LIKE '%test1%';
+
+-- Test 2: Multiple transactions
+BEGIN;
+INSERT INTO regress_cv_test (data) VALUES ('test2');
+INSERT INTO regress_cv_test (data) VALUES ('test3');
+COMMIT;
+
+SELECT count(*) FROM pg_logical_slot_get_changes('regress_cv_test_slot', NULL, NULL) 
+WHERE data LIKE '%test%';
+
+-- Test 3: Verify slot advancement
+SELECT slot_name, confirmed_flush_lsn IS NOT NULL AS has_flush_lsn
+FROM pg_replication_slots 
+WHERE slot_name = 'regress_cv_test_slot';
+
+-- Cleanup
+SELECT pg_drop_replication_slot('regress_cv_test_slot');
+DROP TABLE regress_cv_test;
+
