diff --git a/nostr_publisher.py b/nostr_publisher.py
index 81324fc..2588fcb 100644
--- a/nostr_publisher.py
+++ b/nostr_publisher.py
@@ -19,6 +19,7 @@ from loguru import logger
 
 from .models import Event
 from .nostr.event import NostrEvent
+from .nostr_timestamp import monotonic_created_at
 
 
 def _has_time(value: str | None) -> bool:
@@ -110,9 +111,15 @@ def build_nip52_event(event: Event, pubkey: str) -> NostrEvent:
         if event.fiat_currency:
             tags.append(["tickets_fiat_currency", event.fiat_currency])
 
+    # NIP-52 calendar events are replaceable: this d-tag is republished
+    # whenever inventory changes (a ticket sells). Use a strictly-monotonic
+    # created_at anchored on the last published value so a same-second
+    # republish still outranks the prior version and relays push it to open
+    # subscriptions — a bare int(time.time()) can tie and be silently
+    # dropped, stalling clients' live "tickets remaining" badge.
     nostr_event = NostrEvent(
         pubkey=pubkey,
-        created_at=int(time.time()),
+        created_at=monotonic_created_at(event.nostr_event_created_at),
         kind=kind,
         tags=tags,
         content=event.info or "",
diff --git a/nostr_timestamp.py b/nostr_timestamp.py
new file mode 100644
index 0000000..625b21c
--- /dev/null
+++ b/nostr_timestamp.py
@@ -0,0 +1,34 @@
+"""Monotonic ``created_at`` for replaceable / addressable Nostr events.
+
+Relays only push a replaceable update to OPEN subscriptions when its
+``created_at`` is strictly newer than the version they already hold.
+``created_at`` is integer seconds, so a publisher that stamps
+``int(time.time())`` can emit two versions within the same wall-clock
+second (e.g. two ticket sales republishing the NIP-52 calendar event) —
+the relay treats the second as not-newer and never propagates it to live
+subscribers (it only surfaces on a reload / fresh REQ).
+
+Returning ``max(now, last_created_at + 1)`` guarantees a strictly
+increasing timestamp across successive publishes of the same replaceable
+event. When enough real seconds have elapsed it tracks wall-clock; only
+same-second (or clock-skewed) republishes get nudged forward.
+
+Mirrors the webapp's ``monotonicCreatedAt`` (src/lib/nostr/timestamp.ts)
+and ``docs/nostr-patterns/replaceable-events.md``.
+"""
+
+import time
+
+
+def monotonic_created_at(last_created_at: int | None, now: int | None = None) -> int:
+    """Strictly-newer ``created_at`` for the next publish of a coord.
+
+    :param last_created_at: ``created_at`` of the previously published
+        version (seconds), or ``None`` if none has been published yet.
+    :param now: Current time in seconds — injectable for tests; defaults
+        to ``int(time.time())``.
+    """
+    base = int(time.time()) if now is None else now
+    if last_created_at is None:
+        return base
+    return max(base, last_created_at + 1)
diff --git a/tests/test_nostr_timestamp.py b/tests/test_nostr_timestamp.py
new file mode 100644
index 0000000..693a997
--- /dev/null
+++ b/tests/test_nostr_timestamp.py
@@ -0,0 +1,32 @@
+from itertools import pairwise
+
+from ..nostr_timestamp import monotonic_created_at
+
+
+def test_no_prior_uses_now():
+    assert monotonic_created_at(None, now=1000) == 1000
+
+
+def test_same_second_bumps_past_prior():
+    # now == last: a naive int(time.time()) would tie and the relay would
+    # drop the update; we must produce a strictly newer stamp.
+    assert monotonic_created_at(1000, now=1000) == 1001
+
+
+def test_tracks_wallclock_once_seconds_elapse():
+    assert monotonic_created_at(1000, now=1005) == 1005
+
+
+def test_steps_past_future_dated_prior():
+    # clock skew / rapid bursts left the stored value ahead of now
+    assert monotonic_created_at(2000, now=1000) == 2001
+
+
+def test_strictly_increasing_same_second_burst():
+    last = None
+    stamps = []
+    for _ in range(5):
+        last = monotonic_created_at(last, now=1000)  # clock frozen at 1000
+        stamps.append(last)
+    assert stamps == [1000, 1001, 1002, 1003, 1004]
+    assert all(b > a for a, b in pairwise(stamps))