diff --git a/tests/test_step27_check_for_updates.py b/tests/test_step27_check_for_updates.py
new file mode 100644
index 0000000..d2feda4
--- /dev/null
+++ b/tests/test_step27_check_for_updates.py
@@ -0,0 +1,121 @@
+"""
+Backlog — Manual "Check for updates" button in Settings
+
+- test_check_for_update_button_visible: The button renders in the new Application card
+- test_check_for_update_calls_registration_update: Clicking the button forces a re-check (registration.update())
+- test_check_for_update_shows_up_to_date_when_nothing_found: No update found -> a transient "up to date" message appears, then disappears
+- test_check_for_update_found_still_offers_choice: A manual check that finds an update still shows the Update now / Later modal, not an auto-apply
+- test_up_to_date_message_not_shown_when_update_found: The "up to date" heuristic does not fire when a check does find an update
+
+Uses the dev-only test hook `window.__appUpdateTest.mockCheckFn` (see
+src/composables/useAppUpdate.js) as a stand-in for `registration.update()` —
+simulating a real service-worker update in Playwright would require two
+production builds (see Step 24). page.clock drives the "no update found"
+timeout heuristic deterministically (as in Step 15/26).
+"""
+from playwright.sync_api import Page, expect
+
+
+def _wait_for_db(page: Page, app_url: str):
+ page.goto(app_url)
+ page.wait_for_function(
+ "document.documentElement.getAttribute('data-db-ready') === 'true'",
+ timeout=15000,
+ )
+
+
+def _go_to_settings(page: Page, app_url: str):
+ """Navigate to Settings, waiting for DB and the dev test hook to be ready."""
+ _wait_for_db(page, app_url)
+ page.click('a[href="#/settings"]')
+ page.wait_for_selector('[data-testid="settings-language"]')
+ page.wait_for_function("!!window.__appUpdateTest", timeout=10000)
+
+
+def _mock_check_fn_no_update(page: Page):
+ """Mock registration.update() as a no-op: the check resolves but nothing changes."""
+ page.evaluate("""() => {
+ window.__checkCalls = []
+ window.__appUpdateTest.mockCheckFn = () => {
+ window.__checkCalls.push(true)
+ return Promise.resolve()
+ }
+ }""")
+
+
+def _mock_check_fn_found_update(page: Page):
+ """Mock registration.update() as if it found a new SW: flips `needRefresh`."""
+ page.evaluate("""() => {
+ window.__checkCalls = []
+ window.__appUpdateTest.mockCheckFn = () => {
+ window.__checkCalls.push(true)
+ window.__appUpdateTest.trigger()
+ return Promise.resolve()
+ }
+ }""")
+
+
+def test_check_for_update_button_visible(page: Page, app_url: str):
+ """The 'Check for updates' button renders in the new Application card."""
+ _go_to_settings(page, app_url)
+ expect(page.locator('[data-testid="settings-check-for-update"]')).to_be_visible()
+
+
+def test_check_for_update_calls_registration_update(page: Page, app_url: str):
+ """Clicking the button calls through to registration.update()."""
+ _go_to_settings(page, app_url)
+ _mock_check_fn_no_update(page)
+
+ page.locator('[data-testid="settings-check-for-update"]').click()
+
+ calls = page.evaluate("window.__checkCalls")
+ assert calls == [True], f"registration.update() should have been called, got {calls}"
+
+
+def test_check_for_update_shows_up_to_date_when_nothing_found(page: Page, app_url: str):
+ """No update found: a transient 'up to date' message appears, then disappears."""
+ page.clock.install()
+ _go_to_settings(page, app_url)
+ _mock_check_fn_no_update(page)
+
+ up_to_date = page.locator('[data-testid="settings-up-to-date"]')
+ expect(up_to_date).not_to_be_visible()
+
+ page.locator('[data-testid="settings-check-for-update"]').click()
+ expect(up_to_date).not_to_be_visible() # not shown immediately
+
+ page.clock.run_for(2100)
+ page.wait_for_timeout(100)
+ expect(up_to_date).to_be_visible()
+
+ page.clock.run_for(3100)
+ page.wait_for_timeout(100)
+ expect(up_to_date).not_to_be_visible()
+
+
+def test_check_for_update_found_still_offers_choice(page: Page, app_url: str):
+ """A manual check that finds an update still shows Update now / Later — updating stays optional."""
+ page.clock.install()
+ _go_to_settings(page, app_url)
+ _mock_check_fn_found_update(page)
+
+ page.locator('[data-testid="settings-check-for-update"]').click()
+
+ modal = page.locator('[data-testid="app-update-modal"]')
+ expect(modal).to_be_visible()
+ expect(page.locator('[data-testid="app-update-now"]')).to_be_visible()
+ expect(page.locator('[data-testid="app-update-later"]')).to_be_visible()
+
+
+def test_up_to_date_message_not_shown_when_update_found(page: Page, app_url: str):
+ """The 'up to date' heuristic does not fire when a check does find an update."""
+ page.clock.install()
+ _go_to_settings(page, app_url)
+ _mock_check_fn_found_update(page)
+
+ page.locator('[data-testid="settings-check-for-update"]').click()
+ expect(page.locator('[data-testid="app-update-modal"]')).to_be_visible()
+
+ page.clock.run_for(2100)
+ page.wait_for_timeout(100)
+ expect(page.locator('[data-testid="settings-up-to-date"]')).not_to_be_visible()
diff --git a/website/content/developers/technical.en.md b/website/content/developers/technical.en.md
index 37b4006..13d9ba8 100644
--- a/website/content/developers/technical.en.md
+++ b/website/content/developers/technical.en.md
@@ -1102,6 +1102,7 @@ The service worker was originally registered with `registerType: 'autoUpdate'`:
- `needRefresh` — ref from `useRegisterSW`, true when a new SW is installed and waiting
- `applyUpdate()` — sets `updating`, then calls `updateServiceWorker(true)`; the page reloads when the new SW takes control, so `updating` is never reset
- `dismiss()` — session-only dismissal (plain ref, same pattern as `InstallPrompt`); the modal reappears on the next app load if the update is still pending
+- `checkForUpdate()` / `checkingForUpdate` — see "Manual check" below
**Component:** `AppUpdateDialog.vue`, mounted once in `App.vue`'s DB-ready branch. Two states:
@@ -1112,7 +1113,9 @@ The modal is suppressed while the current route is the execution view (`route.na
**Testing:** simulating a real SW update in Playwright would require two production builds, so `useAppUpdate.js` exposes a dev-only hook (`window.__appUpdateTest`, guarded by `import.meta.env.DEV`) that lets tests force `needRefresh` and mock the update call. The real update flow (deploy old build → deploy new build → prompt → update → reload) is validated manually.
-**Key files:** `vite.config.js`, `src/composables/useAppUpdate.js`, `src/components/AppUpdateDialog.vue`, `src/App.vue`
+**Manual check (Step 27):** the browser only re-fetches the SW script on its own schedule (roughly on navigation/reload), so a PWA left open for a long time can miss an update notification for a while. `useRegisterSW`'s `onRegisteredSW(swScriptUrl, registration)` callback captures the live `registration` into a module-level variable; `checkForUpdate()` calls `registration.update()` to force that re-fetch on demand, setting `checkingForUpdate` around the call. If the script changed, Workbox flips `needRefresh` exactly as it would from a passive check, so `AppUpdateDialog` appears with its usual Update now / Later choice — there is no separate "found via manual check" code path, so a found update is never applied without asking. Settings → **Application** exposes a "Check for updates" button wired to `checkForUpdate()`. Since the Service Worker API has no "no update found" event, `SettingsView.vue` uses a timeout heuristic: if `needRefresh` hasn't flipped ~2s after the check, a transient "You're up to date" message is shown for ~3s. Testing reuses the same dev-only hook, extended with `mockCheckFn` to stand in for `registration.update()`.
+
+**Key files:** `vite.config.js`, `src/composables/useAppUpdate.js`, `src/components/AppUpdateDialog.vue`, `src/App.vue`, `src/views/SettingsView.vue`
---
diff --git a/website/content/docs/user-guide/index.en.md b/website/content/docs/user-guide/index.en.md
index a96b5b2..232530d 100644
--- a/website/content/docs/user-guide/index.en.md
+++ b/website/content/docs/user-guide/index.en.md
@@ -648,6 +648,8 @@ When a new version is available, TrainUs shows an **Update available** dialog. C
If an update changes the database structure, TrainUs shows a one-time update screen at startup. As a safety measure, it asks you to **download a backup** of your data first; the **Update** button becomes available once the backup has been saved. The update then runs in a few seconds and the app continues with all your data in place. If anything were to go wrong, your data is left unchanged and you hold the backup you just downloaded.
+If you keep the app open for a long time, the browser's own update check can be slow to notice a new version. Settings → **Application** has a **Check for updates** button to force a check on demand: if an update is found, the same **Update available** dialog appears with the same **Update now** / **Later** choice; if nothing is found, a brief "You're up to date" message is shown. Checking is always something you choose to do — TrainUs never checks for updates in the background — and updating stays your choice even when a check does find one.
+
The regular backup reminder remains your day-to-day safety net.
In the Database section, you can also see:
diff --git a/website/content/docs/user-guide/index.fr.md b/website/content/docs/user-guide/index.fr.md
index 083185a..e85cba4 100644
--- a/website/content/docs/user-guide/index.fr.md
+++ b/website/content/docs/user-guide/index.fr.md
@@ -650,6 +650,8 @@ Quand une nouvelle version est disponible, TrainUs affiche une boîte de dialogu
Si une mise à jour change la structure de la base de données, TrainUs affiche un écran de mise à jour unique au démarrage. Par sécurité, il vous demande d'abord de **télécharger une sauvegarde** de vos données ; le bouton **Mettre à jour** devient disponible une fois la sauvegarde enregistrée. La mise à jour s'exécute alors en quelques secondes et l'application continue avec toutes vos données en place. Si quoi que ce soit devait mal se passer, vos données restent inchangées et vous disposez de la sauvegarde que vous venez de télécharger.
+Si vous laissez l'application ouverte longtemps, la vérification automatique du navigateur peut mettre du temps à détecter une nouvelle version. Réglages → **Application** propose un bouton **Vérifier les mises à jour** pour forcer une vérification à la demande : si une mise à jour est trouvée, la même boîte de dialogue **Mise à jour disponible** s'affiche, avec le même choix **Mettre à jour** / **Plus tard** ; sinon, un bref message « Vous êtes à jour » apparaît. La vérification est toujours une action volontaire — TrainUs ne vérifie jamais en arrière-plan — et la mise à jour reste votre choix même lorsqu'une vérification en trouve une.
+
Le rappel de sauvegarde habituel reste votre filet de sécurité au quotidien.
Dans la section base de données, vous pouvez aussi voir :