diff --git a/__tests__/unit/app/components/mobileapplink/MobileAppLink.test.js b/__tests__/unit/app/components/mobileapplink/MobileAppLink.test.js
new file mode 100644
index 0000000000..c64f70e482
--- /dev/null
+++ b/__tests__/unit/app/components/mobileapplink/MobileAppLink.test.js
@@ -0,0 +1,209 @@
+/* global jest */
+/* global expect */
+/* global describe */
+/* global it */
+/* global beforeEach */
+/* global afterEach */
+
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import MobileAppLink, {
+  ANDROID_APP_URL,
+  APP_STORE_URL,
+  IOS_APP_URL,
+  IOS_UNIVERSAL_LINK_URL,
+  PLAY_STORE_URL,
+  getIosAppUrl,
+} from '@app/components/mobileapplink/MobileAppLink';
+import utils from '@app/core/utils';
+
+const OPEN_APP_LABEL = 'Open the Tidepool Mobile app';
+const STORE_BADGE_LABEL = 'Download Tidepool Mobile';
+
+describe('MobileAppLink', () => {
+  let getMobilePlatform;
+  let trackMetric;
+
+  beforeEach(() => {
+    getMobilePlatform = jest.spyOn(utils, 'getMobilePlatform');
+    trackMetric = jest.fn();
+    // The iosLink override persists to localStorage, so tests must not leak state into each other
+    window.localStorage.clear();
+  });
+
+  afterEach(() => {
+    getMobilePlatform.mockRestore();
+  });
+
+  describe('on a desktop user agent', () => {
+    it('should render nothing, since the link cannot work there', () => {
+      getMobilePlatform.mockReturnValue(null);
+      const { container } = render(<MobileAppLink trackMetric={trackMetric} />);
+
+      expect(container).toBeEmptyDOMElement();
+    });
+  });
+
+  describe('on iOS', () => {
+    beforeEach(() => {
+      getMobilePlatform.mockReturnValue('ios');
+    });
+
+    it('should link to the app with the plain custom scheme', () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+
+      expect(screen.getByRole('link', { name: OPEN_APP_LABEL }))
+        .toHaveAttribute('href', IOS_APP_URL);
+      expect(IOS_APP_URL).toBe('org.tidepool.mobile://signup-complete');
+    });
+
+    it('should fall back to the App Store listing', () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+
+      expect(screen.getByRole('link', { name: STORE_BADGE_LABEL }))
+        .toHaveAttribute('href', APP_STORE_URL);
+    });
+
+    it('should track a metric when the app link is clicked', async () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+      await userEvent.click(screen.getByRole('link', { name: OPEN_APP_LABEL }));
+
+      expect(trackMetric).toHaveBeenCalledWith('Clicked Open Tidepool Mobile App', { platform: 'ios' });
+    });
+  });
+
+  describe('getIosAppUrl', () => {
+    it('should default to the custom scheme', () => {
+      expect(getIosAppUrl('')).toBe(IOS_APP_URL);
+    });
+
+    it('should return the universal link when overridden via the query string', () => {
+      expect(getIosAppUrl('?iosLink=universal')).toBe(IOS_UNIVERSAL_LINK_URL);
+    });
+
+    it('should return the custom scheme when explicitly overridden', () => {
+      expect(getIosAppUrl('?iosLink=scheme')).toBe(IOS_APP_URL);
+    });
+
+    it('should ignore an unrecognised override', () => {
+      expect(getIosAppUrl('?iosLink=nonsense')).toBe(IOS_APP_URL);
+    });
+
+    it('should point at the current origin when testing the same-host case', () => {
+      expect(getIosAppUrl('?iosLink=universal&linkHost=same', 'https://qa1.development.tidepool.org'))
+        .toBe('https://qa1.development.tidepool.org/mobile-app');
+    });
+
+    it('should ignore linkHost when the scheme strategy is selected', () => {
+      expect(getIosAppUrl('?iosLink=scheme&linkHost=same', 'https://qa1.development.tidepool.org'))
+        .toBe(IOS_APP_URL);
+    });
+
+    // The value renders into an href, so an attacker-supplied host would repoint the button off-site.
+    it('should not honour an arbitrary host supplied in the query string', () => {
+      expect(getIosAppUrl('?iosLink=universal&linkHost=evil.example.com', 'https://qa1.development.tidepool.org'))
+        .toBe(IOS_UNIVERSAL_LINK_URL);
+    });
+
+    // Safari opens same-host universal links in the browser rather than the app, so pointing this
+    // at the host serving the page would silently defeat the whole mechanism.
+    it('should point the universal link at a dedicated host', () => {
+      expect(IOS_UNIVERSAL_LINK_URL).toMatch(/^https:\/\/[^/]+\/mobile-app$/);
+    });
+
+    // Editing query params on a phone keyboard is painful, so an override sticks across visits.
+    describe('override persistence', () => {
+      it('should keep applying an override on later visits without the query param', () => {
+        getIosAppUrl('?iosLink=universal');
+
+        expect(getIosAppUrl('')).toBe(IOS_UNIVERSAL_LINK_URL);
+      });
+
+      it('should persist the same-host variant, including the host choice', () => {
+        getIosAppUrl('?iosLink=universal&linkHost=same', 'https://qa3.development.tidepool.org');
+
+        expect(getIosAppUrl('', 'https://qa3.development.tidepool.org'))
+          .toBe('https://qa3.development.tidepool.org/mobile-app');
+      });
+
+      it('should drop a persisted linkHost when a later override omits it', () => {
+        getIosAppUrl('?iosLink=universal&linkHost=same', 'https://qa3.development.tidepool.org');
+        getIosAppUrl('?iosLink=universal', 'https://qa3.development.tidepool.org');
+
+        expect(getIosAppUrl('', 'https://qa3.development.tidepool.org')).toBe(IOS_UNIVERSAL_LINK_URL);
+      });
+
+      it('should return to the default after ?iosLink=reset', () => {
+        getIosAppUrl('?iosLink=universal');
+        getIosAppUrl('?iosLink=reset');
+
+        expect(getIosAppUrl('')).toBe(IOS_APP_URL);
+      });
+
+      it('should not persist an unrecognised override', () => {
+        getIosAppUrl('?iosLink=nonsense');
+
+        expect(window.localStorage.getItem('mobileAppLink.iosLink')).toBeNull();
+      });
+    });
+  });
+
+  describe('override indicator', () => {
+    beforeEach(() => {
+      getMobilePlatform.mockReturnValue('ios');
+    });
+
+    it('should not render while no override is active', () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+
+      expect(screen.queryByText(/Link override active/)).not.toBeInTheDocument();
+    });
+
+    it('should name the active override and how to clear it', () => {
+      getIosAppUrl('?iosLink=universal&linkHost=same', 'https://qa3.development.tidepool.org');
+      render(<MobileAppLink trackMetric={trackMetric} />);
+
+      expect(screen.getByText('Link override active: universal (same host) — ?iosLink=reset clears it'))
+        .toBeInTheDocument();
+    });
+  });
+
+  describe('on Android', () => {
+    beforeEach(() => {
+      getMobilePlatform.mockReturnValue('android');
+    });
+
+    it('should link to the app with the intent:// scheme, so a missing app falls through to the Play Store', () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+
+      expect(screen.getByRole('link', { name: OPEN_APP_LABEL }))
+        .toHaveAttribute('href', ANDROID_APP_URL);
+      expect(ANDROID_APP_URL).toBe('intent://signup-complete#Intent;scheme=org.tidepool.mobile;package=io.tidepool.urchin;S.browser_fallback_url=https%3A%2F%2Fplay.google.com%2Fstore%2Fapps%2Fdetails%3Fid%3Dio.tidepool.urchin;end');
+    });
+
+    it('should fall back to the Play Store listing', () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+
+      expect(screen.getByRole('link', { name: STORE_BADGE_LABEL }))
+        .toHaveAttribute('href', PLAY_STORE_URL);
+    });
+
+    // The visible target is a Button nested inside the anchor, so a real tap lands on the button
+    // and relies on the click bubbling up to trigger the link.
+    it('should trigger the app link when the button itself is tapped', async () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+      await userEvent.click(screen.getByRole('button', { name: OPEN_APP_LABEL }));
+
+      expect(trackMetric).toHaveBeenCalledWith('Clicked Open Tidepool Mobile App', { platform: 'android' });
+    });
+
+    it('should track a metric when the app link is clicked', async () => {
+      render(<MobileAppLink trackMetric={trackMetric} />);
+      await userEvent.click(screen.getByRole('link', { name: OPEN_APP_LABEL }));
+
+      expect(trackMetric).toHaveBeenCalledWith('Clicked Open Tidepool Mobile App', { platform: 'android' });
+    });
+  });
+});
diff --git a/__tests__/unit/app/pages/mobileapp/MobileApp.test.js b/__tests__/unit/app/pages/mobileapp/MobileApp.test.js
new file mode 100644
index 0000000000..da41b86a85
--- /dev/null
+++ b/__tests__/unit/app/pages/mobileapp/MobileApp.test.js
@@ -0,0 +1,61 @@
+/* global jest */
+/* global expect */
+/* global describe */
+/* global it */
+/* global beforeEach */
+/* global afterEach */
+
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+
+import MobileApp from '@app/pages/mobileapp/MobileApp';
+import { APP_STORE_URL, PLAY_STORE_URL } from '@app/components/mobileapplink/MobileAppLink';
+import utils from '@app/core/utils';
+
+const BADGE_LABEL = 'Download Tidepool Mobile';
+
+describe('MobileApp', () => {
+  let getMobilePlatform;
+
+  beforeEach(() => {
+    getMobilePlatform = jest.spyOn(utils, 'getMobilePlatform');
+  });
+
+  afterEach(() => {
+    getMobilePlatform.mockRestore();
+  });
+
+  it('should show only the App Store badge on iOS', () => {
+    getMobilePlatform.mockReturnValue('ios');
+    render(<MobileApp />);
+
+    const badges = screen.getAllByRole('link', { name: BADGE_LABEL });
+    expect(badges).toHaveLength(1);
+    expect(badges[0]).toHaveAttribute('href', APP_STORE_URL);
+  });
+
+  it('should show only the Play Store badge on Android', () => {
+    getMobilePlatform.mockReturnValue('android');
+    render(<MobileApp />);
+
+    const badges = screen.getAllByRole('link', { name: BADGE_LABEL });
+    expect(badges).toHaveLength(1);
+    expect(badges[0]).toHaveAttribute('href', PLAY_STORE_URL);
+  });
+
+  // Unlike the Welcome page button, this page must still render on desktop — it is a real
+  // destination that a universal link resolves to when the app isn't installed.
+  it('should show both badges on desktop rather than rendering nothing', () => {
+    getMobilePlatform.mockReturnValue(null);
+    render(<MobileApp />);
+
+    expect(screen.getAllByRole('link', { name: BADGE_LABEL })).toHaveLength(2);
+  });
+
+  it('should offer a manual scheme link on iOS as a retry path', () => {
+    getMobilePlatform.mockReturnValue('ios');
+    render(<MobileApp />);
+
+    expect(screen.getByText('Open the Tidepool Mobile app')).toBeInTheDocument();
+  });
+});
diff --git a/app/components/mobileapplink/MobileAppLink.js b/app/components/mobileapplink/MobileAppLink.js
new file mode 100644
index 0000000000..91874f031b
--- /dev/null
+++ b/app/components/mobileapplink/MobileAppLink.js
@@ -0,0 +1,196 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { withTranslation } from 'react-i18next';
+import { Box, Flex, Image, Link } from 'theme-ui';
+
+import Button from '../elements/Button';
+import { Paragraph1 } from '../elements/FontStyles';
+import utils from '../../core/utils';
+
+import AppStoreBadge from './images/appstore-badge.svg';
+import GooglePlayBadge from './images/google-play-badge.png';
+
+export const APP_STORE_URL = 'https://apps.apple.com/us/app/tidepool-mobile/id1026395200';
+export const PLAY_STORE_URL = 'https://play.google.com/store/apps/details?id=io.tidepool.urchin';
+
+// The link only foregrounds the app — it carries no parameters and the app does no routing on it.
+export const IOS_APP_URL = 'org.tidepool.mobile://signup-complete';
+
+export const IOS_UNIVERSAL_LINK_PATH = '/mobile-app';
+
+// Host serving /.well-known/apple-app-site-association. iOS suppresses universal links that point
+// at the current page's own host (opens them in Safari instead of the app), so this must be a host
+// other than the one serving the page. Suppression is same-host only — a sibling subdomain works —
+// both verified on hardware 2026-09-03 (see docs/mobile-app-signup/). This is a QA test value;
+// shipping requires the real link host here (e.g. link.tidepool.org), with a matching entry in the
+// iOS app's associated-domains entitlement.
+export const IOS_UNIVERSAL_LINK_HOST = 'qa4.development.tidepool.org';
+export const IOS_UNIVERSAL_LINK_URL = `https://${IOS_UNIVERSAL_LINK_HOST}${IOS_UNIVERSAL_LINK_PATH}`;
+
+// Which link form iOS gets. 'scheme' is the shipped behaviour. 'universal' is fully verified
+// (opens the app when installed, lands on IOS_UNIVERSAL_LINK_URL when not, never errors) but
+// shipping it needs production infrastructure — see docs/mobile-app-signup/ — so the default stays
+// 'scheme' until that decision is made. Override with ?iosLink=universal|scheme (sticky, see below)
+// to compare both on a single build.
+export const IOS_LINK_STRATEGY = 'scheme';
+
+export const IOS_LINK_STORAGE_KEY = 'mobileAppLink.iosLink';
+export const IOS_LINK_HOST_STORAGE_KEY = 'mobileAppLink.linkHost';
+
+// localStorage can throw (private browsing, storage disabled); a failed read/write just means the
+// override doesn't stick, which only degrades the test workflow, never the shipped behaviour.
+const storage = {
+  get: (key) => { try { return window.localStorage.getItem(key); } catch (e) { return null; } },
+  set: (key, value) => { try { window.localStorage.setItem(key, value); } catch (e) { /* noop */ } },
+  remove: (key) => { try { window.localStorage.removeItem(key); } catch (e) { /* noop */ } },
+};
+
+/**
+ * Resolve the iOS link strategy for the current page load.
+ *
+ * ?iosLink=universal|scheme  selects the link form
+ * ?linkHost=same             points the universal link at the current origin (the step 1 control —
+ *                            it confirmed iOS suppresses same-host universal links)
+ * ?iosLink=reset             clears a persisted override
+ *
+ * A query-string override is persisted on the device and keeps applying on later visits until it
+ * is replaced or reset — editing query params by hand on a phone keyboard is painful, so the URL
+ * only ever needs to be typed (or a prepared link tapped) once per mode. Each iosLink visit
+ * re-persists linkHost according to its presence, so the stored state always mirrors the last
+ * override URL used. An on-page indicator shows when an override is active.
+ *
+ * linkHost only accepts 'same' rather than an arbitrary host: this renders into an href, and
+ * honouring a caller-supplied domain would let a crafted URL repoint the button off-site.
+ */
+export const resolveIosLinkStrategy = (search = '') => {
+  const params = new URLSearchParams(search);
+  const override = params.get('iosLink');
+
+  if (override === 'reset') {
+    storage.remove(IOS_LINK_STORAGE_KEY);
+    storage.remove(IOS_LINK_HOST_STORAGE_KEY);
+  } else if (['scheme', 'universal'].includes(override)) {
+    storage.set(IOS_LINK_STORAGE_KEY, override);
+
+    if (params.get('linkHost') === 'same') {
+      storage.set(IOS_LINK_HOST_STORAGE_KEY, 'same');
+    } else {
+      storage.remove(IOS_LINK_HOST_STORAGE_KEY);
+    }
+  }
+
+  const stored = storage.get(IOS_LINK_STORAGE_KEY);
+  const isOverride = ['scheme', 'universal'].includes(stored);
+  const strategy = isOverride ? stored : IOS_LINK_STRATEGY;
+
+  return {
+    strategy,
+    sameHost: strategy === 'universal' && storage.get(IOS_LINK_HOST_STORAGE_KEY) === 'same',
+    isOverride,
+  };
+};
+
+export const getIosAppUrl = (search = '', origin = '') => {
+  const { strategy, sameHost } = resolveIosLinkStrategy(search);
+
+  if (strategy !== 'universal') return IOS_APP_URL;
+
+  return sameHost && origin
+    ? `${origin}${IOS_UNIVERSAL_LINK_PATH}`
+    : IOS_UNIVERSAL_LINK_URL;
+};
+
+// Chrome's intent:// syntax, so that a missing app falls through to the Play Store listing instead
+// of failing silently. iOS has no equivalent fallback — Safari shows an "address is invalid" alert —
+// which is why the store badge sits directly below the button.
+export const ANDROID_APP_URL = [
+  'intent://signup-complete#Intent',
+  'scheme=org.tidepool.mobile',
+  'package=io.tidepool.urchin',
+  `S.browser_fallback_url=${encodeURIComponent(PLAY_STORE_URL)}`,
+  'end',
+].join(';');
+
+const platformConfig = {
+  ios: {
+    getAppUrl: getIosAppUrl,
+    storeUrl: APP_STORE_URL,
+    badgeImage: AppStoreBadge,
+    badgeMetric: 'Clicked App Store Badge',
+  },
+  android: {
+    getAppUrl: () => ANDROID_APP_URL,
+    storeUrl: PLAY_STORE_URL,
+    badgeImage: GooglePlayBadge,
+    badgeMetric: 'Clicked Play Store Badge',
+  },
+};
+
+/**
+ * Renders a link back to the Tidepool Mobile app, for users who arrived on the web to complete
+ * signup and would otherwise be stranded here. Renders nothing outside of iOS and Android, where
+ * the link cannot work.
+ */
+export const MobileAppLink = (props) => {
+  const { t, trackMetric } = props;
+  const platform = utils.getMobilePlatform();
+
+  if (!platform) return null;
+
+  const { getAppUrl, storeUrl, badgeImage, badgeMetric } = platformConfig[platform];
+  const appUrl = getAppUrl(window.location.search, window.location.origin);
+  const iosLink = platform === 'ios' ? resolveIosLinkStrategy(window.location.search) : null;
+
+  return (
+    <Flex
+      id="mobile-app-link"
+      mb={4}
+      sx={{ flexDirection: 'column', alignItems: 'center', textAlign: 'center' }}
+    >
+      <Link
+        id="mobile-app-link-open"
+        href={appUrl}
+        onClick={() => trackMetric('Clicked Open Tidepool Mobile App', { platform })}
+        sx={{ textDecoration: 'none' }}
+      >
+        <Button variant="primary" sx={{ fontSize: 2 }}>
+          {t('Open the Tidepool Mobile app')}
+        </Button>
+      </Link>
+
+      {/* Test scaffolding, so deliberately untranslated: visible only while a persisted
+          ?iosLink override is active, so the device's current mode is never a mystery. */}
+      {iosLink?.isOverride && (
+        <Paragraph1 id="mobile-app-link-override" mt={2} sx={{ fontSize: 0, color: '#66788A' }}>
+          {`Link override active: ${iosLink.strategy}${iosLink.sameHost ? ' (same host)' : ''} — ?iosLink=reset clears it`}
+        </Paragraph1>
+      )}
+
+      <Paragraph1 mt={3} mb={2} sx={{ fontWeight: 'medium' }}>
+        {t('Don\'t have the app yet?')}
+      </Paragraph1>
+
+      <Box>
+        <Link
+          id="mobile-app-link-store"
+          href={storeUrl}
+          target="_blank"
+          rel="noreferrer noopener"
+          onClick={() => trackMetric(badgeMetric, { platform })}
+        >
+          <Image
+            src={badgeImage}
+            alt={t('Download Tidepool Mobile')}
+            sx={{ height: '40px' }}
+          />
+        </Link>
+      </Box>
+    </Flex>
+  );
+};
+
+MobileAppLink.propTypes = {
+  trackMetric: PropTypes.func.isRequired,
+};
+
+export default withTranslation()(MobileAppLink);
diff --git a/app/components/browserwarning/images/appstore-badge.svg b/app/components/mobileapplink/images/appstore-badge.svg
similarity index 100%
rename from app/components/browserwarning/images/appstore-badge.svg
rename to app/components/mobileapplink/images/appstore-badge.svg
diff --git a/app/components/browserwarning/images/google-play-badge.png b/app/components/mobileapplink/images/google-play-badge.png
similarity index 100%
rename from app/components/browserwarning/images/google-play-badge.png
rename to app/components/mobileapplink/images/google-play-badge.png
diff --git a/app/components/mobileapplink/index.js b/app/components/mobileapplink/index.js
new file mode 100644
index 0000000000..cadf293725
--- /dev/null
+++ b/app/components/mobileapplink/index.js
@@ -0,0 +1,3 @@
+import MobileAppLink from './MobileAppLink';
+
+export default MobileAppLink;
diff --git a/app/core/utils.js b/app/core/utils.js
index f0e3329d94..6161599257 100644
--- a/app/core/utils.js
+++ b/app/core/utils.js
@@ -109,6 +109,24 @@ utils.isMobile = () => {
   return (userAgent.indexOf('mobi') > -1);
 };
 
+/**
+ * Identify the mobile platform from the user agent, for cases where a viewport-width media query
+ * (see MobileOnly) isn't sufficient because the behaviour differs per platform.
+ *
+ * Note that iPadOS 13+ requests desktop sites by default and reports itself as a Mac, so an iPad
+ * will generally return null here.
+ *
+ * @return {String|null} 'ios', 'android', or null when neither
+ */
+utils.getMobilePlatform = () => {
+  const userAgent = navigator.userAgent.toLowerCase();
+
+  if (/iphone|ipad|ipod/.test(userAgent)) return 'ios';
+  if (userAgent.indexOf('android') > -1) return 'android';
+
+  return null;
+};
+
 utils.validateEmail = email => {
   var re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
   return re.test(email);
diff --git a/app/keycloak.js b/app/keycloak.js
index 300bdde89b..cea0208a68 100644
--- a/app/keycloak.js
+++ b/app/keycloak.js
@@ -72,8 +72,11 @@ export const onKeycloakEvent = (store) => (event, error) => {
     }
     case 'onAuthSuccess': {
       const isOauthRedirectRoute = /^\/oauth\//.test(window?.location?.pathname);
+      // The mobile-app page is a universal-link landing target: like the oauth redirect pages, it
+      // must not trigger the login flow, whose redirect would immediately navigate away from it
+      const isMobileAppLandingRoute = /^\/mobile-app\/?$/.test(window?.location?.pathname);
       // We don't trigger the login (and subsequent redirects) on the oauth redirect landing page
-      if (!isOauthRedirectRoute) {
+      if (!isOauthRedirectRoute && !isMobileAppLandingRoute) {
         store.dispatch(sync.keycloakAuthSuccess(event, error));
         api.user.saveSession(
           keycloak?.tokenParsed?.sub,
diff --git a/app/pages/mobileapp/MobileApp.js b/app/pages/mobileapp/MobileApp.js
new file mode 100644
index 0000000000..08e229c90d
--- /dev/null
+++ b/app/pages/mobileapp/MobileApp.js
@@ -0,0 +1,72 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { withTranslation } from 'react-i18next';
+import { Box, Flex, Image, Link } from 'theme-ui';
+
+import { Title, Paragraph1 } from '../../components/elements/FontStyles';
+import {
+  APP_STORE_URL,
+  PLAY_STORE_URL,
+  IOS_APP_URL,
+} from '../../components/mobileapplink/MobileAppLink';
+import utils from '../../core/utils';
+
+import AppStoreBadge from '../../components/mobileapplink/images/appstore-badge.svg';
+import GooglePlayBadge from '../../components/mobileapplink/images/google-play-badge.png';
+
+/**
+ * Landing page for the universal link target (see static/.well-known/apple-app-site-association).
+ *
+ * When the app is installed, iOS intercepts the link and this page is never rendered. It is only
+ * reached when the app is missing, or when the link is opened somewhere universal links don't
+ * fire (desktop, some in-app browsers), so it exists purely to route the user to the right store.
+ */
+export const MobileApp = (props) => {
+  const { t } = props;
+  const platform = utils.getMobilePlatform();
+
+  const badges = [
+    { key: 'ios', storeUrl: APP_STORE_URL, image: AppStoreBadge },
+    { key: 'android', storeUrl: PLAY_STORE_URL, image: GooglePlayBadge },
+  ].filter(({ key }) => !platform || key === platform);
+
+  return (
+    <Flex
+      id="mobile-app-landing"
+      sx={{ flexDirection: 'column', alignItems: 'center', textAlign: 'center', height: '75vh', justifyContent: 'center' }}
+    >
+      <Title mb={3}>{t('Get the Tidepool Mobile app')}</Title>
+
+      <Paragraph1 mb={4} sx={{ fontWeight: 'medium', maxWidth: '420px' }}>
+        {t('If you already have the Tidepool Mobile app installed, it should have opened automatically. Otherwise, download it below.')}
+      </Paragraph1>
+
+      {platform === 'ios' && (
+        <Link
+          id="mobile-app-landing-open"
+          href={IOS_APP_URL}
+          mb={4}
+          sx={{ fontWeight: 'bold' }}
+        >
+          {t('Open the Tidepool Mobile app')}
+        </Link>
+      )}
+
+      <Flex sx={{ gap: 3, flexWrap: 'wrap', justifyContent: 'center' }}>
+        {badges.map(({ key, storeUrl, image }) => (
+          <Box key={key}>
+            <Link href={storeUrl} target="_blank" rel="noreferrer noopener">
+              <Image src={image} alt={t('Download Tidepool Mobile')} sx={{ height: '40px' }} />
+            </Link>
+          </Box>
+        ))}
+      </Flex>
+    </Flex>
+  );
+};
+
+MobileApp.propTypes = {
+  t: PropTypes.func,
+};
+
+export default withTranslation()(MobileApp);
diff --git a/app/pages/mobileapp/index.js b/app/pages/mobileapp/index.js
new file mode 100644
index 0000000000..b719ae6fdd
--- /dev/null
+++ b/app/pages/mobileapp/index.js
@@ -0,0 +1,3 @@
+import MobileApp from './MobileApp';
+
+export default MobileApp;
diff --git a/app/pages/patientdata/patientdata.js b/app/pages/patientdata/patientdata.js
index 22428e47ad..01ef2f7871 100644
--- a/app/pages/patientdata/patientdata.js
+++ b/app/pages/patientdata/patientdata.js
@@ -59,6 +59,7 @@ import Checkbox from '../../components/elements/Checkbox';
 import PopoverLabel from '../../components/elements/PopoverLabel';
 import { Paragraph1, Paragraph2 } from '../../components/elements/FontStyles';
 import Card from '../../components/elements/Card';
+import MobileAppLink from '../../components/mobileapplink';
 import UploaderBanner from '../../components/elements/Card/Banners/Uploader.png';
 import ShareBanner from '../../components/elements/Card/Banners/Share.png';
 import DataConnectionsBanner from '../../components/elements/Card/Banners/DataConnections.png';
@@ -338,6 +339,8 @@ export const PatientDataClass = createReactClass({
               </MobileOnly>
             </Grid>
 
+            {isUserPatient && <MobileAppLink trackMetric={this.props.trackMetric} />}
+
             <Flex
               sx={{
                 flexDirection: 'column',
diff --git a/app/routes.js b/app/routes.js
index 0af660f4e2..566e8e4bbf 100644
--- a/app/routes.js
+++ b/app/routes.js
@@ -16,6 +16,7 @@ import Workspaces from './pages/workspaces';
 import ConfirmPasswordReset from './pages/passwordreset/confirm';
 import EmailVerification from './pages/emailverification';
 import Login from './pages/login';
+import MobileApp from './pages/mobileapp';
 import { PrescriptionForm } from './pages/prescription';
 import OAuthConnection from './pages/oauth/OAuthConnection';
 import PatientData from './pages/patientdata';
@@ -463,6 +464,8 @@ export const getRoutes = (appContext) => {
           <Route path='/login' render={routeProps => (<Gate onEnter={boundRequireNoAuth} key={routeProps.match.path}><Login {...routeProps} {...props} /></Gate>)} />
           <Route path='/smart-on-fhir' render={routeProps => (<Gate onEnter={boundRequireSmartOnFhir} key={routeProps.match.path}><SmartOnFhir {...routeProps} {...props} /></Gate>)} />
           <Route path='/terms' render={routeProps => (<Terms {...routeProps} {...props} />)} />
+          {/* Universal link target — must stay unauthenticated, since it is reached from the app store flow */}
+          <Route path='/mobile-app' render={routeProps => (<MobileApp {...routeProps} {...props} />)} />
           <Route path='/signup' render={routeProps => (<Gate onEnter={boundRequireNoAuth} key={routeProps.match.path}><Signup {...routeProps} {...props} /></Gate>)} />
           <Route path='/clinic-admin' render={routeProps => (<Gate onEnter={boundRequireAuth} key={routeProps.match.path}><ClinicAdmin {...routeProps} {...props} /></Gate>)} />
           <Route path='/clinic-details/:action' render={routeProps => (<Gate onEnter={boundRequireAuth} key={routeProps.match.path}><ClinicDetails {...routeProps} {...props} /></Gate>)} />
diff --git a/docs/mobile-app-signup/blip-signup-return-handoff.md b/docs/mobile-app-signup/blip-signup-return-handoff.md
new file mode 100644
index 0000000000..d0f44c30fe
--- /dev/null
+++ b/docs/mobile-app-signup/blip-signup-return-handoff.md
@@ -0,0 +1,80 @@
+# Handoff: "Return to the Tidepool Mobile app" button after web signup
+
+**Audience**: the agent/developer implementing the web (blip) half of this feature.
+**Mobile half**: already implemented in `mobile-remix` (branch `improve-signup-flow`) — see *What the mobile app already does* below. The two halves are independently shippable; the button is useless-but-harmless until the mobile release with the scheme registration is in the field (the store-badge fallback covers those users).
+
+## Goal
+
+Mobile-app signup currently dead-ends in the browser: the app opens `https://{env}/signup` externally, the user verifies their email (which continues signup in whatever browser the email client opens), walks the signup steps (data donation → "connect a device account" / "share your data"), and is then stranded on the web with no path back to the app. Add a **"Open the Tidepool Mobile app"** button to the final signup page that returns the user to the app.
+
+**Repo scoping note**: the onboarding pages (data donation, "connect a device account" / "share your data") are blip, and the button lives on a blip page — all changes in this doc are blip changes. But Tidepool auth is Keycloak-based, so the credential-creation form and quite possibly the verification email + its link target may be served by Keycloak, not blip. Nothing in this doc requires touching those — but if anything about the verification email needs changing, look in Keycloak config/themes first, not blip.
+
+## Design decision (already settled — do not redesign)
+
+**Custom URL scheme**, not iOS universal links / Android app links. Reasons, for context:
+
+- Universal links don't fire when tapped from a page on the same domain they point to — and this button lives on a Tidepool page. They also don't fire from most email-client in-app browsers, which is exactly where post-email-verification traffic lands.
+- App links need domain verification files (`apple-app-site-association` / `assetlinks.json`) served on **every** environment host (prod + QA/dev) plus per-domain app entitlements; the custom scheme works identically on all environments with zero server config.
+- The link carries nothing sensitive (it only foregrounds the app), so the classic custom-scheme weakness (any app can claim a scheme) has no payload to leak.
+
+## The link
+
+```
+org.tidepool.mobile://signup-complete
+```
+
+- **Do not add query parameters** — the app ignores them (and its OAuth intent handling is scheme-guarded), but nothing reads them, so they'd be dead weight.
+- **Never put this link in an email.** Email clients strip or refuse custom-scheme links. It belongs on the final signup web page only.
+
+## What the mobile app already does
+
+- **iOS** registers the `org.tidepool.mobile` scheme (`CFBundleURLTypes` in `Info.plist`). Tapping the link launches/foregrounds the app. There is deliberately no URL routing — a signed-out app lands on its Sign In screen, which is the desired destination (the user's web session does not transfer; they authenticate in-app via OAuth).
+- **Android** registers an intent filter for `org.tidepool.mobile://signup-complete` on `MainActivity` (`io.tidepool.urchin`). Same behavior: foreground only, no routing. `MainActivity.onNewIntent` only treats `org.tidepool.mobile.auth://` URIs as OAuth callbacks, so this link can't be misparsed.
+- The existing `org.tidepool.mobile.auth://redirect` scheme is the OAuth callback — **do not use it for this button.**
+
+## What to build on blip
+
+On the final signup page (the "connect a device account" / "share your data" step), add a **user-agent-gated** section:
+
+1. **Gate by mobile UA.** Render the section only for iOS/Android user agents. Desktop users (common after the email-verification hop — many people open the verification link on a laptop) must not see a button that can't work; show them nothing, or just the store badges.
+
+2. **The button, per platform:**
+   - **Android UAs** — use Chrome's `intent://` syntax so "app not installed" falls through to the Play Store instead of failing silently:
+     ```
+     intent://signup-complete#Intent;scheme=org.tidepool.mobile;package=io.tidepool.urchin;S.browser_fallback_url=https%3A%2F%2Fplay.google.com%2Fstore%2Fapps%2Fdetails%3Fid%3Dio.tidepool.urchin;end
+     ```
+   - **iOS UAs** — a plain link to `org.tidepool.mobile://signup-complete`. iOS has no fallback mechanism: if the app isn't installed, Safari shows an "address is invalid" alert, which is why the store badges below must be visually adjacent. Do **not** use the old JS trick of racing the scheme against a `setTimeout` App Store redirect — it's unreliable on modern iOS and the error alert fires anyway.
+
+3. **Store badges** (both platforms, below the button) as the not-installed fallback:
+   - Play Store: `https://play.google.com/store/apps/details?id=io.tidepool.urchin`
+   - App Store: link to the **Tidepool Mobile** listing (iOS bundle `org.tidepool.blipnotes`). ⚠️ **Verify the numeric App Store ID yourself** — it was not resolvable from the mobile repo or its network sandbox. Look it up with:
+     ```
+     curl "https://itunes.apple.com/lookup?bundleId=org.tidepool.blipnotes"
+     ```
+     and use `trackId`/`trackViewUrl` from the response. Do not guess the ID. (It's also visible in App Store Connect → the app → App Information → "Apple ID". Note it is NOT any ID found in the mobile repo's CI config: `ASC_KEY_ID` there is an App Store Connect API-key credential and `app_identifier` is the bundle ID — the Smart App Banner needs the numeric store ID, e.g. the `id123456789` in the listing URL.)
+
+4. **Smart App Banner** (iOS, optional but recommended): add to the page `<head>`:
+   ```html
+   <meta name="apple-itunes-app" content="app-id=<VERIFIED_APP_STORE_ID>">
+   ```
+   Safari renders a native banner — "Open" when the app is installed, "View" (→ App Store) when not. Safari-only (it won't render in Chrome-on-iOS or email in-app browsers), so it complements the button rather than replacing it.
+
+## Environments
+
+Nothing environment-specific: the same scheme link works against prod and every QA/dev host. No server config, no per-domain files.
+
+## Known imperfections (accepted in the design)
+
+- Some email-client in-app webviews block unknown schemes silently; the store badges are the recovery path.
+- iOS user without the app who taps the button gets the "address is invalid" alert before noticing the badges. Rare: the page is the tail of signup, and mobile signups almost always originate from the app.
+- A user who started in the app but opens the verification email on another phone (without the app) hits the fallback path — expected.
+
+## Test checklist
+
+- [x] iOS Safari, app installed → tap opens Tidepool Mobile (foregrounds; Sign In if signed out) — verified 2026-09-03 on a dev build; Safari shows its `Open in "Tidepool Mobile"?` confirmation first, which is standard for custom schemes
+- [x] iOS Safari, app NOT installed → **confirmed 2026-09-03**: "Safari cannot open the page because the address is invalid." alert, as predicted. (Store badge adjacency/function and Smart App Banner not yet verified; the banner was never implemented — see step 3 options in `blip-universal-link-next-steps.md`)
+- [x] Android Chrome, app installed → `intent://` link opens the app — verified on real hardware
+- [x] Android Chrome, app NOT installed → `intent://` link lands on the Play Store listing — verified on real hardware
+- [ ] Gmail in-app browser (both platforms) after tapping a verification email → button visible and functional (or store badge path works)
+- [ ] Desktop browser → no dead button rendered
+- [ ] Works identically on a QA environment host (no prod-only assumptions)
diff --git a/docs/mobile-app-signup/blip-universal-link-next-steps.md b/docs/mobile-app-signup/blip-universal-link-next-steps.md
new file mode 100644
index 0000000000..c4a855c5fa
--- /dev/null
+++ b/docs/mobile-app-signup/blip-universal-link-next-steps.md
@@ -0,0 +1,454 @@
+# Next steps: iOS universal link prototype
+
+**Companion to** `blip-signup-return-handoff.md` (the original spec for the "return to the app"
+button). That doc's design decision — custom URL scheme, universal links rejected — is the thing
+being re-examined here. Read it first for background.
+
+**Branch**: `mobile-signup-workflow`
+**Repo**: blip. The iOS half lives in `mobile-remix` (branch `improve-signup-flow`).
+
+> ## Status 2026-09-03: PARKED — shipping the custom scheme instead
+>
+> Decision: ship step 3, option 1 (custom scheme, unchanged from what's committed on
+> `mobile-signup-workflow`). The iOS not-installed case keeps the "address is invalid" alert, with
+> the App Store badge directly below the button as the recovery path. Rationale: step 1 confirmed
+> same-host suppression, so universal links require a dedicated link host + a mobile entitlement
+> release + cross-team host coordination — real infrastructure for a marginal UX gain on a rare
+> path.
+>
+> The prototype is **complete through step 1** and preserved on the `universal-link-prototype`
+> branch (this doc travels with it). Step 1's result (suppression confirmed, setup validated by
+> the Notes control) means resuming is cheap: the only open question left is step 2
+> (cross-subdomain).
+>
+> **Update, same day**: qa3 **and qa4** turned out to be free, so step 2 ran before parking —
+> qa3/qa4 are siblings under `development.tidepool.org`, the strict analog of the production
+> `app`/`link.tidepool.org` pair. `IOS_UNIVERSAL_LINK_HOST` now points at qa4.
+>
+> **EXPERIMENT COMPLETE, both steps ✅**: same-host suppression is real (step 1), sibling-subdomain
+> links work perfectly (step 2) — app opens when installed, landing page when not, never an error.
+> The technique is proven; what remains to ship it is purely infrastructure and process (see
+> step 3): a real link host serving the AASA, a production entitlement (without `?mode=developer`,
+> so a mobile release), and validating once on the real host pair since Apple's CDN — bypassed by
+> developer mode — sits in the production fetch path. Whether that cost is paid now or later is a
+> product decision; the custom scheme remains the shipped behaviour until it's made.
+
+---
+
+## Where things stand
+
+### Shipped and working (committed in `1bc1d4157`)
+
+The "Open the Tidepool Mobile app" button on the Welcome page.
+
+| Piece | Location |
+|---|---|
+| Component | `app/components/mobileapplink/MobileAppLink.js` |
+| Render gate | `app/pages/patientdata/patientdata.js:342` — `{isUserPatient && <MobileAppLink … />}` |
+| UA detection | `app/core/utils.js` — `utils.getMobilePlatform()` returns `'ios' \| 'android' \| null` |
+| Tests | `__tests__/unit/app/components/mobileapplink/MobileAppLink.test.js` |
+
+The page is `/patients/:userid/data`, rendered by `renderNoData` (`patientdata.js:261`) when the
+patient has no device data. It requires all three of: viewing your *own* record (`isUserPatient`),
+no device data, and an iOS/Android user agent.
+
+**Verified on real hardware:**
+- ✅ Android Chrome, app installed → `intent://` opens the app
+- ✅ Android Chrome, app uninstalled → falls through to the Play Store
+- ✅ iOS Safari, app installed (dev build from Xcode), custom scheme → `Open in "Tidepool Mobile"?`
+  dialog → app opens to Sign In (2026-09-03, full signup flow walked end-to-end)
+- ✅ iOS Safari, app **removed**, custom scheme → *"Safari cannot open the page because the address
+  is invalid."* (2026-09-03) — the degradation this experiment exists to fix, now reproduced
+  first-hand rather than assumed
+
+**Not yet tested:** the App Store badge link working from a real device (the artwork has been seen
+rendering on the landing page), Gmail in-app browser (both platforms). Steps 1 and 2 are **both
+done** — see the result sections below: suppression is same-host only, and the two-host design
+works completely.
+
+### Uncommitted — the universal link prototype
+
+All changes are in the working tree, unstaged.
+
+```
+ M __tests__/unit/app/components/mobileapplink/MobileAppLink.test.js
+ M app/components/mobileapplink/MobileAppLink.js
+ M app/routes.js
+ M server.js
+ M webpack.config.js
+?? __tests__/unit/app/pages/mobileapp/
+?? app/pages/mobileapp/
+?? static/.well-known/
+```
+
+| File | Purpose |
+|---|---|
+| `static/.well-known/apple-app-site-association` | The association file. `.well-known/` is **required** for developer mode |
+| `server.js:128-139` | Production route forcing `application/json` (the file is extensionless, so `express.static` can't infer the type). Serves from memory — read once at startup — after a CodeQL alert about unratelimited per-request filesystem access |
+| `webpack.config.js` → `devServer.setupMiddlewares` | Same for dev; also stops `historyApiFallback` swallowing the path |
+| `app/pages/mobileapp/MobileApp.js` | Landing page the universal link resolves to when the app isn't installed |
+| `app/routes.js:468` | Unauthenticated route `/mobile-app` |
+| `MobileAppLink.js:25`, `:31`, `:43` | `IOS_UNIVERSAL_LINK_HOST`, `IOS_LINK_STRATEGY`, `getIosAppUrl()` |
+
+Status: 20 tests passing, lint clean. AASA verified served locally over a real dev server —
+`HTTP 200`, `Content-Type: application/json; charset=utf-8`, `num_redirects=0`.
+
+**Default behaviour is unchanged.** iOS still gets the custom scheme. The universal link only
+activates via an explicit query param, so none of this regresses the working Android path.
+
+---
+
+## Why we're doing this
+
+iOS currently degrades badly. With the app not installed, `org.tidepool.mobile://signup-complete`
+makes Safari show an **"address is invalid" alert** — whereas Android falls through cleanly to the
+Play Store via `S.browser_fallback_url`. The goal is iOS parity: open the app, or land somewhere
+useful, but never error.
+
+A universal link would fix this — it resolves to a real page when the app is missing. The blocker
+in the original doc is that **iOS suppresses universal links pointing at the current page's own
+host**, opening them in Safari instead. Apple documents this in the App Search Programming Guide.
+Sibling subdomains reportedly count as different hosts, so `app.tidepool.org` → `link.tidepool.org`
+should work.
+
+**That suppression claim is the premise of the entire design, and it has not been verified for our
+setup. Verifying it is step 1.**
+
+---
+
+## Step 1 — Does same-host suppression actually happen?
+
+If it doesn't, no link subdomain is needed, the design collapses to a single host, and most of the
+complexity disappears. Worth knowing before building anything else.
+
+### The trap
+
+A bare negative test is worthless. "The app didn't open" is equally consistent with suppression, a
+malformed AASA, a wrong Team ID, a bundle-ID mismatch, or the device toggle being off. **You need a
+positive control.** Two work on a single host:
+
+1. **`swcutil verify`** — proves the file is fetched and the path pattern matches:
+   ```bash
+   swcutil verify -d qa3.development.tidepool.org \
+     -j <path-to-aasa> \
+     -u https://qa3.development.tidepool.org/mobile-app
+   ```
+
+2. **Long-press the link** (the decisive one). If the context menu offers **"Open in Tidepool
+   Mobile"**, iOS has recognised it as a valid universal link — so a plain tap staying in Safari is
+   deliberate suppression, not broken config.
+
+### Setup
+
+> **Update 2026-09-03**: the branch is actually deployed to **`qa3`**, not qa1 — substitute
+> `qa3.development.tidepool.org` for `qa1` throughout this doc. The AASA on qa3 is verified in
+> full: `status=200 redirects=0 type=application/json`, and the body carries the real appID
+> `75U4X84TEG.org.tidepool.blipnotes` claiming `/mobile-app`. The server half needs nothing more.
+
+1. ✅ Placeholders filled: the AASA carries `75U4X84TEG.org.tidepool.blipnotes`.
+
+2. ✅ Deployed to `qa3` and verified:
+   ```bash
+   curl -i https://qa3.development.tidepool.org/.well-known/apple-app-site-association
+   ```
+   `200`, `application/json`, **no redirects** — Apple rejects redirects.
+
+3. In `mobile-remix`, add **both** hosts to the associated-domains entitlement now, even though
+   step 1 only uses one. Costs nothing and avoids a rebuild for step 2 (full instructions for the
+   mobile side: `mobile-remix-applinks-handoff.md`). ⚠️ Earlier drafts said qa1/qa2 — a build
+   carrying only those will silently never match on qa3:
+   ```
+   applinks:qa3.development.tidepool.org?mode=developer
+   applinks:qa4.development.tidepool.org?mode=developer
+   ```
+   (`qa4` is the second host — qa1/qa2 turned out to be in use by others; if the
+   step 2 deploy lands on a different host instead, update both the constant and the entitlement.)
+
+4. Build to a physical device from Xcode. `?mode=developer` requires a **development-signed** build
+   — TestFlight and Ad Hoc cannot use it. Enable **Settings → Developer → Associated Domains
+   Development** on the device.
+
+   `?mode=developer` isn't strictly required for a public QA host, but Apple's CDN caches AASA
+   files; developer mode fetches direct from the host so edits take effect immediately.
+
+### Run it
+
+Load the Welcome page on `qa3` as a patient with no data, then:
+
+```
+/patients/<userid>/data?iosLink=universal&linkHost=same
+```
+
+`linkHost=same` points the link at `window.location.origin`.
+
+**The override is sticky (added 2026-09-03, needs the redeploy).** Typing query params on a phone
+is painful, so an `?iosLink` override persists on the device (localStorage) and keeps applying on
+every later visit until replaced or cleared with `?iosLink=reset`. While one is active, a caption
+under the button says so (e.g. *"Link override active: universal (same host)"*), so the device's
+mode is never a mystery. Practical upshot: prepare the full URLs once on the Mac and get them to
+the phone without typing — AirDrop/iMessage the link, or make a QR code
+(`qrencode -o mode.png 'https://qa3.development.tidepool.org/patients/<userid>/data?iosLink=universal&linkHost=same'`)
+and scan it with the camera. After that one tap, plain navigation stays in that mode. One constraint: the
+override only persists when the button actually renders — so the override URL must be the Welcome
+page itself (mobile UA, own record, no data), which the protocol's URL already is.
+
+### Findings from the first device run (2026-09-03)
+
+- **Bug found and fixed: the landing page bounced authenticated users.** Tapping the button
+  navigated to `/mobile-app`, which rendered — then the page redirected back to the Welcome page.
+  Cause: `keycloak.js` `onAuthSuccess` dispatches `async.login(api)` on every authenticated page
+  load, and that action always ends in a `push()` to the user's home route. Fixed by excluding
+  `/mobile-app` from the login trigger, the same carve-out the oauth landing pages already use
+  (`app/keycloak.js`, tested in `test/unit/keycloak.test.js`). **Needs a redeploy to qa3** before
+  the landing page can be evaluated again. This mattered beyond the test: real post-signup users
+  are authenticated too.
+- **Long-pressing the button produces no callout menu at all** — not even the standard link
+  preview. Likely the markup: the anchor wraps a `<button>` (theme-ui `Button` inside `Link`), and
+  the button appears to swallow the gesture. So the button itself can't serve as the long-press
+  positive control. Use Apple Notes instead: paste
+  `https://qa3.development.tidepool.org/mobile-app` into a note, long-press it there — "Open in
+  Tidepool Mobile" in that menu is the same signal.
+- **The tap itself navigated to `/mobile-app` (no error alert).** Interpretation blocked on two
+  facts about the run: whether the app was installed at the time, and whether the build's
+  entitlements actually contain `applinks:qa3…?mode=developer` (`codesign -d --entitlements -`).
+  If the app was absent, this is simply the desired not-installed behaviour and says nothing about
+  suppression. If it was present with valid entitlements, this is same-host suppression confirmed.
+
+### Interpreting the result
+
+| Observation | Conclusion | Next |
+|---|---|---|
+| Long-press shows "Open in…", tap stays in Safari | **Suppression confirmed** | Go to step 2 |
+| Tap opens the app | **Premise is wrong** — no link subdomain needed | Skip step 2. Simplify: point the universal link at the page's own host and drop the two-host design |
+| Long-press shows nothing | Setup problem, not suppression | Fix AASA / Team ID / bundle ID / device toggle. Conclude nothing yet |
+
+The middle row is the good outcome — it would mean universal links are implementable with no new
+infrastructure.
+
+### ✅ Step 1 result (2026-09-03): same-host suppression CONFIRMED
+
+- **Positive control passed**: the URL `https://qa3.development.tidepool.org/mobile-app` pasted
+  into Apple Notes **opens the app on tap**. That proves the entire chain — AASA on qa3, the
+  build's entitlement, signing team, device toggle — is valid. (The on-page long-press control
+  turned out unusable: the anchor wraps a `<button>` that swallows the gesture; Notes is the
+  reliable control.)
+- **Same-host tap in Safari stays in the browser**: on the qa3 Welcome page with
+  `?iosLink=universal&linkHost=same`, tapping the button navigated to `/mobile-app` instead of
+  opening the installed app.
+- Conclusion: iOS suppresses universal links pointing at the current page's own host, exactly as
+  the original handoff claimed. **The single-host simplification is dead; a separate link host is
+  required. Proceed to step 2** (sibling subdomain, qa3 page → qa4 link).
+- Also verified along the way, app **not** installed: the same tap lands on `/mobile-app` with
+  **no error alert** — the iOS degradation this design set out to fix, working.
+
+---
+
+## Step 2 — Cross-subdomain (only if step 1 confirms suppression)
+
+Deploy blip to a **second** QA host (`qa4`). Since blip serves the AASA from `static/`, that host
+gets the file automatically.
+
+⚠️ Gotchas hit here on 2026-09-03, both diagnosed via the Notes positive control failing for qa4
+while qa3 kept working:
+
+- **Order matters**: iOS validates domain associations **at app install**. An app installed before
+  the host's AASA went live never associates with it — delete and reinstall from Xcode *after* the
+  deploy is confirmed. This was the actual failure.
+- **A 200 on the AASA URL proves nothing by itself**: blip's catch-all serves `index.html` with a
+  200 for *any* path, so an old build answers 200 with HTML. Always check the body for the appID.
+- Most informative diagnostic on-device: **Settings → Developer → Universal Links → Diagnostics**,
+  paste the URL, it says whether it's linked to the app and why not.
+
+Load the Welcome page on **`qa3`**, tap with:
+
+```
+/patients/<userid>/data?iosLink=universal
+```
+
+This defaults to `IOS_UNIVERSAL_LINK_HOST` (`MobileAppLink.js:25`, currently `qa4.development.tidepool.org`).
+
+Expected: the app opens. This tests **sibling subdomains**, which is the genuinely uncertain case
+and the one the eventual `app.tidepool.org` → `link.tidepool.org` design depends on. A cross-domain
+test would prove less.
+
+Then delete the app and repeat — should land on `/mobile-app` showing the App Store badge, **with no
+error alert**. That is the entire point of the exercise.
+
+Control: `?iosLink=scheme` reproduces current shipped behaviour for comparison. Both strategies work
+on one build, no rebuild needed to switch.
+
+### ✅ Step 2 result (2026-09-03): sibling-subdomain universal links WORK
+
+On the qa3 Welcome page with `?iosLink=universal` (button → `https://qa4…/mobile-app`):
+
+- **App installed → tap opens the app.** Suppression does *not* extend to sibling subdomains;
+  it is same-host only, as hoped.
+- **App not installed → tap lands on qa4's `/mobile-app` landing page, no error alert.**
+
+Combined with step 1, the full behaviour matrix of the production design
+(`app.tidepool.org` page → `link.tidepool.org` link) is now empirically verified: the link must
+live on a sibling host (same-host is suppressed), and on a sibling host it opens the app or
+degrades to a useful page — never Safari's "address is invalid" alert. One caution before
+declaring victory: mind the persisted override when interpreting any run — an accidental
+`(same host)` state re-runs step 1 and mimics a step 2 failure. The on-page indicator exists for
+exactly this; it caught one such near-miss during this run.
+
+---
+
+## Step 3 — If it works, decide what to ship
+
+Options, roughly increasing cost:
+
+- **Keep the custom scheme.** Android already works; iOS keeps the error alert. ← **CHOSEN
+  2026-09-03**, see status note at the top.
+- **Point the iOS button at the App Store listing** (`apps.apple.com/...`, Apple's own URL —
+  no AASA/entitlement/link host needed). The store page is the switch: "Open" when installed,
+  "Get" when not. Installed users pay a detour through the store but the tap count equals the
+  scheme's confirmation dialog (two), the not-installed case never errors, and it works in email
+  in-app browsers. What Apple does **not** offer is a hosted URL that opens a third-party app
+  directly and falls back to the store — that always requires domain association (universal
+  links) or a third-party service like Branch (Firebase Dynamic Links was discontinued 2025).
+  Considered and **rejected** 2026-09-03: the button's primary audience is users who already have
+  the app (they started signup in it), and "Open the Tidepool Mobile app" routing them through a
+  store page first is wrong — the store detour optimises the rare case at the expense of the
+  common one. Kept here only so it isn't re-proposed.
+- **Universal link on iOS, `intent://` on Android.** Needs a real link host and an entitlement change
+  (therefore a mobile release). The two halves stop being independently shippable.
+- **Add the Smart App Banner.** Skipped earlier, and cheap-ish. Safari-only, Apple-sanctioned, gives
+  "Open" when installed and "View" when not. Blocked on blip having no react-helmet — head content
+  comes from a single `index.ejs` (`webpack.config.js:177`), so a `<meta name="apple-itunes-app">`
+  there applies app-wide, not just to the Welcome page.
+
+Whatever ships, the **Android side should not change** — `intent://` with `browser_fallback_url` is
+verified working and is the right mechanism there.
+
+### If/when universal links ship: the PR checklist
+
+Everything on this branch is built so that shipping is configuration, not rework:
+
+1. Stand up the link host (e.g. `link.tidepool.org`) serving the AASA and `/mobile-app`. **This
+   does not require a new server**: iOS judges same-host suppression by the URL's hostname string,
+   not the backend, so an alias (DNS + TLS + ingress) pointing at the *existing* `app.tidepool.org`
+   blip deployment suffices — blip already serves both paths. Use a purpose-named alias rather than
+   reusing an existing one like `api.tidepool.org`: the API gateway doesn't serve the landing page,
+   its redirect/rewrite rules can silently break the AASA's no-redirect requirement, and claiming
+   the API host in the app's entitlement is a pointless coupling.
+2. `IOS_UNIVERSAL_LINK_HOST` → the real host; `IOS_LINK_STRATEGY` → `'universal'`.
+3. Mobile release with a production entitlement: `applinks:link.tidepool.org` (no
+   `?mode=developer`). Ship order matters: entitlement + AASA must be live **before** the blip
+   change flips the default, and note app installs only pick up associations at install/update.
+4. Validate once on the real host pair from a TestFlight build — the production AASA fetch goes
+   through Apple's CDN, which every developer-mode test bypassed. This is the only untested link
+   in the chain.
+5. Decide the fate of the test scaffolding (`?iosLink` sticky override + on-page indicator): keep
+   it through the TestFlight validation — it's how you flip strategies without redeploying — then
+   strip it (or leave it; it's inert without the query param and invisible without an override).
+
+---
+
+## Open questions — blockers
+
+### 1. Apple Team ID and bundle ID
+
+✅ **Resolved 2026-09-01**: `static/.well-known/apple-app-site-association` now carries the real
+appID `75U4X84TEG.org.tidepool.blipnotes`.
+
+- **Bundle ID** — confirmed: `mobile-remix` uses `org.tidepool.blipnotes`, same as the 2020 listing.
+- **Team ID** — confirmed: `75U4X84TEG`.
+
+(A wrong appID fails silently, so if universal links mysteriously don't match, re-check this value
+against the build's actual signing team before concluding anything.)
+
+### 2. App Store listing
+
+✅ **Confirmed 2026-09-01**: `mobile-remix` ships under the same listing the badge points at
+(`https://apps.apple.com/us/app/tidepool-mobile/id1026395200`, bundle `org.tidepool.blipnotes`).
+The badge URL is correct as-is.
+
+### 3. Badge artwork
+
+`appstore-badge.svg` and `google-play-badge.png` sat unreferenced in the repo since May 2024 (moved
+from `app/components/browserwarning/images/` — nothing imported them). The Play Store badge has now
+been seen rendering on a real device. The App Store one has never been displayed; check it against
+Apple's current brand guidelines during the iOS pass.
+
+### 4. How to deploy to QA
+
+✅ **Resolved 2026-09-01**: Gerrit deploys the branch to a QA host after pushing. For the record,
+the mechanism explored earlier: there is **no `.github/` directory in blip and never has been**, so no workflow here
+could respond to a `/deploy` PR comment. CI is Travis (`.travis.yml`) building a Docker image and
+publishing a versioned artifact. The live convention in `git log` is branch-named prerelease version
+bumps in `package.json` (`v1.101.0-feat-blip-2fa.1`, `v1.100.0-web-4275-landing-c2c.1`). The README's
+table of contents links to a "Build and deployment" section that doesn't exist in the file.
+
+Ask whoever last cut a release — Clint made the `v1.101.0-feat-blip-2fa.1` bump.
+
+---
+
+## Local dev gotchas (hard-won)
+
+- **`API_HOST` must be set**, or it silently falls back to the page origin (`config.app.js:51`), so
+  `/info` hits the dev server, `historyApiFallback` returns `index.html` with a `200`, Keycloak never
+  initialises, and you get `Cannot read properties of null (reading 'createLoginUrl')`.
+  ```bash
+  API_HOST=http://localhost:31500 UPLOAD_API=http://localhost:31500 yarn start
+  ```
+  It's a build-time `DefinePlugin` constant — **restart the dev server** after changing it.
+
+- **Local cluster port is 31500** (`config/local.example.js:31`), not 8009. `config/local.sh` says
+  8009 but is dead — untouched since 2018 and referenced by nothing. Worth deleting upstream.
+
+- **Testing from a phone needs every port reversed**, not just 3000, because `API_HOST` is an
+  absolute URL baked into the bundle:
+  ```bash
+  adb reverse tcp:3000  tcp:3000     # blip
+  adb reverse tcp:31500 tcp:31500    # gateway/API
+  ```
+  Plus Keycloak's port — find it from `curl -s http://localhost:31500/info | grep -A4 '"auth"'`.
+  `adb reverse` also keeps the origin at `localhost:3000`, which is what QA CORS allowlists expect.
+
+- **Chrome's "Desktop site" toggle** strips `Android` from the UA, so `getMobilePlatform()` returns
+  null and the button vanishes. Most likely cause of a "missing" button.
+
+- **`package=io.tidepool.urchin`** is pinned in the intent URL. A debug build with an
+  `applicationIdSuffix` won't match and silently falls through to the Play Store. Check with
+  `adb shell pm list packages | grep -i tidepool`.
+
+- **Isolate the app half first**, before involving the browser:
+  ```bash
+  adb shell am start -a android.intent.action.VIEW -d "org.tidepool.mobile://signup-complete"
+  ```
+
+- **`node_modules` may be in an npm-resolved state.** Jest wasn't installed in the devcontainer, and
+  corepack can't reach `repo.yarnpkg.com` from behind the egress firewall, so test deps were
+  installed with `npm install --no-save`. Run a real `yarn install` outside the container before
+  trusting the checkout. (`package.json` and `yarn.lock` are unmodified — npm rewrote `yarn.lock`
+  once and it was reverted.)
+
+- **Cluster startup failures seen so far**, both fixed:
+  - auth service: *"big data donation project data recipient user id is required"* → set
+    `BigDataDonationProjectSharingDisabled: "true"` in the `auth` configmap (the chart default;
+    `Disabled` short-circuits before the user-id check).
+  - clinic service: `IndexKeySpecsConflict` on `PatientDeletion` → upstream bug.
+    `patients/repository/repository.go:48` passes `[]string{"clinicId,userId"}` (one string with a
+    comma) instead of `[]string{"clinicId", "userId"}`, producing a malformed single-field index.
+    Drop all indexes on `*_deletions` collections and restart. The one-line upstream fix is worth
+    reporting.
+
+---
+
+## Test commands
+
+```bash
+# targeted (AGENTS.md: never run the full suite)
+TZ=UTC NODE_ENV=test yarn test:jest --testPathPattern="mobileapplink|mobileapp"
+TZ=UTC NODE_ENV=test yarn test:jest --testPathPattern="patientdata"
+NODE_ENV=development yarn lint
+```
+
+## Conventions
+
+- `AGENTS.md` restricts agents to **read-only git commands**. Leave everything unstaged; the user
+  commits.
+- New tests go in `__tests__/` as Jest. Existing Karma files in `test/` get extended in place.
+- Never read `config/local.js` or any `.env` file.
diff --git a/docs/mobile-app-signup/mobile-remix-applinks-handoff.md b/docs/mobile-app-signup/mobile-remix-applinks-handoff.md
new file mode 100644
index 0000000000..9ac951b6d7
--- /dev/null
+++ b/docs/mobile-app-signup/mobile-remix-applinks-handoff.md
@@ -0,0 +1,115 @@
+# Handoff: add Associated Domains (universal links) to the mobile-remix iOS build
+
+> **Status 2026-09-03: step 2 in progress** (briefly un-parked — qa4 became available). The
+> mobile-side ask right now: the dev build's entitlement needs
+> `applinks:qa4.development.tidepool.org?mode=developer` added (qa3 is already validated; a qa2
+> entry, if present, is dead — that host belongs to another team), then rebuild + reinstall on the
+> test device. Everything else below still applies. The web ship decision remains the custom
+> scheme; these entitlements are developer-mode-only and inert in TestFlight/App Store builds.
+
+**Audience**: the agent/developer working in the `mobile-remix` repo (branch `improve-signup-flow`).
+**Written**: 2026-09-01. Companion docs live in the blip repo: `blip-signup-return-handoff.md`
+(original feature spec) and `blip-universal-link-next-steps.md` (the experiment this build supports).
+
+## Context in three sentences
+
+Blip's post-signup Welcome page has an "Open the Tidepool Mobile app" button. On iOS it currently
+uses the custom scheme `org.tidepool.mobile://signup-complete`, which shows Safari's "address is
+invalid" alert when the app isn't installed. We are testing whether an iOS **universal link** can
+replace it (open the app when installed, land on a real web page when not) — the web half is done
+and will be deployed to two QA hosts; the missing piece is the app claiming those hosts, and as of
+2026-09-01 the project has **no `applinks` entries anywhere in the code**.
+
+## The change
+
+Add the **Associated Domains** capability to the iOS app target with exactly these two entries:
+
+```
+applinks:qa3.development.tidepool.org?mode=developer
+applinks:qa4.development.tidepool.org?mode=developer
+```
+
+> **Update 2026-09-03**: blip is deployed to **qa3** (AASA verified live there), so `qa3` replaced
+> `qa1` in the list above. If an earlier build used qa1/qa2, it will silently never match on qa3 —
+> rebuild with the corrected list.
+
+Both hosts now, even though the first test only uses one — it costs nothing and avoids a rebuild
+when the cross-subdomain test (the one that actually matters) runs.
+
+Where to make it:
+
+- **Plain Xcode project**: target → *Signing & Capabilities* → *+ Capability* → *Associated
+  Domains* → add both entries. This writes a `com.apple.developer.associated-domains` array into
+  the target's `.entitlements` file; commit that file.
+- **If entitlements are generated** (Expo config plugin, React Native config, fastlane templates,
+  XcodeGen/Tuist project generation…): make the change at the generating source instead, then
+  verify the generated `.entitlements` contains both strings verbatim — including the
+  `?mode=developer` suffix, which some tooling mangles.
+
+Do **not** touch:
+
+- The existing `CFBundleURLTypes` registration of `org.tidepool.mobile` — it is the shipped
+  behaviour and the experiment's control (`?iosLink=scheme` on the web side).
+- `org.tidepool.mobile.auth://` OAuth handling.
+- Anything on Android — the Android path is verified working and out of scope.
+
+## No URL-handling code is needed
+
+The desired behaviour when the link fires is simply that the app opens/foregrounds (signed-out
+users land on Sign In — that's the destination we want). Universal links arrive as an
+`NSUserActivity` of type `NSUserActivityTypeBrowsingWeb` (via
+`application(_:continue:restorationHandler:)` / the scene equivalent), **not** via `openURL`, and
+an unhandled activity still opens the app. So: add no routing.
+
+One check worth doing: if the app already implements a user-activity/scene handler (e.g. for
+OAuth or Handoff), make sure an incoming `https://qa*.development.tidepool.org/mobile-app` URL
+falls through harmlessly rather than hitting an assertion or being misparsed as an OAuth callback.
+
+## Signing constraints — read before building
+
+- `?mode=developer` domains are honoured **only in development-signed builds**. TestFlight, Ad Hoc,
+  and App Store builds ignore them completely. Build to the device from Xcode with *Run*; do not
+  bother producing a TestFlight build for this experiment — it cannot work.
+- The build must sign under team **`75U4X84TEG`** with bundle ID **`org.tidepool.blipnotes`**. The
+  server-side association file declares the appID `75U4X84TEG.org.tidepool.blipnotes`; a build
+  signed by any other team (e.g. a personal team) will fail **silently** — no error, links just
+  never match. Note that Associated Domains is a capability a free personal team can't sign anyway.
+- Physical iPhone, and turn on **Settings → Developer → Associated Domains Development** on it.
+  (Developer mode makes the device fetch the association file directly from the QA host instead of
+  through Apple's caching CDN, so server-side edits take effect immediately.)
+
+## Verifying your half works (before any end-to-end test)
+
+1. Confirm the built product's entitlements:
+   ```bash
+   codesign -d --entitlements - <path-to-built .app>
+   ```
+   Expect `com.apple.developer.associated-domains` with both `applinks:` strings.
+
+2. From the Mac, prove the server file matches the app (this needs the blip branch deployed to the
+   QA host first — coordinate with Gerrit):
+   ```bash
+   swcutil verify -d qa3.development.tidepool.org \
+     -u https://qa3.development.tidepool.org/mobile-app
+   ```
+   The association file is served at
+   `https://qa3.development.tidepool.org/.well-known/apple-app-site-association`
+   (must be HTTP 200, `application/json`, no redirects). The only path it claims is `/mobile-app`.
+
+3. On the device, install the build, then in Safari **long-press** a link to
+   `https://qa3.development.tidepool.org/mobile-app`. If the context menu offers **"Open in
+   Tidepool Mobile"**, your half is done — everything beyond that (whether a plain tap opens the
+   app from various pages) is the blip-side experiment, scripted in
+   `blip-universal-link-next-steps.md`.
+
+If the long-press menu shows nothing: recheck, in order — signing team is `75U4X84TEG`, the device
+toggle is on, the entitlement survived into the built product (step 1), and the AASA is reachable
+(step 2). Don't conclude anything from a plain tap until the long-press control passes.
+
+## What comes later (not now)
+
+If the experiment succeeds, production would need a real entry **without** `?mode=developer`
+(normal mode goes through Apple's CDN and works in TestFlight/App Store builds) pointing at
+whatever host the final design lands on — possibly `link.tidepool.org`, possibly the app's own
+host, depending on what the experiment shows about same-host suppression. **Don't add any
+production `applinks` entry yet**; the host is undecided.
diff --git a/package.json b/package.json
index 73d5967397..73e4c71fdf 100644
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
     "node": "24.15.0"
   },
   "packageManager": "yarn@3.6.4",
-  "version": "1.101.0-feat-blip-2fa.1",
+  "version": "1.101.0-universal-link-prototype.1",
   "private": true,
   "scripts": {
     "test": "TZ=UTC NODE_ENV=test yarn jest --verbose",
diff --git a/server.js b/server.js
index fc418bb8d7..0458fcbb94 100644
--- a/server.js
+++ b/server.js
@@ -125,6 +125,19 @@ app.get('/silent-check-sso.html', (req, res) => {
   res.send(res.locals.ssoHtmlWithNonces);
 });
 
+// The apple-app-site-association file has no extension, so express.static cannot infer its type —
+// Apple requires application/json, with no redirects. Read once at startup and served from memory,
+// so the handler does no per-request filesystem access.
+const appleAppSiteAssociation = fs.readFileSync(
+  path.join(staticDir, '.well-known', 'apple-app-site-association'),
+  'utf8'
+);
+
+app.get('/.well-known/apple-app-site-association', (req, res) => {
+  res.type('application/json');
+  res.send(appleAppSiteAssociation);
+});
+
 app.use(express.static(staticDir, { index: false }));
 
 //So that we can use react-router and browser history
diff --git a/static/.well-known/apple-app-site-association b/static/.well-known/apple-app-site-association
new file mode 100644
index 0000000000..79894bc800
--- /dev/null
+++ b/static/.well-known/apple-app-site-association
@@ -0,0 +1,15 @@
+{
+  "applinks": {
+    "details": [
+      {
+        "appIDs": ["75U4X84TEG.org.tidepool.blipnotes"],
+        "components": [
+          {
+            "/": "/mobile-app",
+            "comment": "Return to the Tidepool Mobile app after completing signup on the web"
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/test/unit/keycloak.test.js b/test/unit/keycloak.test.js
index 4e5b620c9a..5b734c1a63 100644
--- a/test/unit/keycloak.test.js
+++ b/test/unit/keycloak.test.js
@@ -171,6 +171,22 @@ describe('keycloak', () => {
       expect(api.user.saveSession.mock.calls.length).to.equal(1);
     });
 
+    it('should not dispatch keycloakAuthSuccess or trigger login for onAuthSuccess on the mobile-app landing page', () => {
+      const originalLocation = window.location;
+      delete window.location;
+      window.location = { pathname: '/mobile-app' };
+
+      const store = mockStore();
+      const onEvent = onKeycloakEvent(store);
+
+      onEvent('onAuthSuccess', null);
+
+      expect(store.getActions()).to.eql([]);
+      expect(api.user.saveSession.mock.calls.length).to.equal(0);
+
+      window.location = originalLocation;
+    });
+
     it('should dispatch keycloakAuthError for onAuthError', () => {
       const store = mockStore();
       const onEvent = onKeycloakEvent(store);
diff --git a/test/unit/pages/patientdata.test.js b/test/unit/pages/patientdata.test.js
index 7122ab1fa3..c34fef1241 100644
--- a/test/unit/pages/patientdata.test.js
+++ b/test/unit/pages/patientdata.test.js
@@ -28,6 +28,7 @@ const t = i18next.t.bind(i18next);
 // We must remember to require the base module when mocking dependencies,
 // otherwise dependencies mocked will be bound to the wrong scope!
 import PD, { PatientData, PatientDataClass, getFetchers, mapStateToProps } from '../../../app/pages/patientdata/patientdata.js';
+import MobileAppLink from '../../../app/components/mobileapplink';
 import { DEFAULT_CGM_SAMPLE_INTERVAL_RANGE, MGDL_UNITS, MS_IN_MIN, ONE_MINUTE_CGM_SAMPLE_INTERVAL_RANGE } from '../../../app/core/constants';
 
 jest.mock('../../../app/core/dataViewUtils', () => {
@@ -599,11 +600,46 @@ describe('PatientData', function () {
     describe('no data available', () => {
       let dataConnectionsCard
       let uploaderCard;
+      let mobileAppLink;
       let wrapper;
 
       beforeEach(() => {
         dataConnectionsCard = () => wrapper.find('#data-connections-card');
         uploaderCard = () => wrapper.find('#uploader-card');
+        mobileAppLink = () => wrapper.find(MobileAppLink);
+      });
+
+      describe('mobile app link', () => {
+        const renderWithNoData = (props) => {
+          const mountProps = _.assign({}, defaultProps, {
+            fetchingPatient: false,
+            fetchingPatientData: false,
+            removingData: { inProgress: false },
+            generatingPDF: { inProgress: false },
+            pdf: {},
+            isSmartOnFhirMode: false,
+          }, props);
+
+          wrapper = shallow(<PatientDataClass {...mountProps} />);
+
+          wrapper.setProps(_.assign({}, mountProps, {
+            data: {
+              metaData: { size: 0 },
+            }
+          }));
+        };
+
+        it('should render the mobile app link when the logged-in user is viewing their own data', function() {
+          renderWithNoData({ isUserPatient: true });
+
+          expect(mobileAppLink().length).to.equal(1);
+        });
+
+        it('should not render the mobile app link when the logged-in user is viewing another patient', function() {
+          renderWithNoData({ isUserPatient: false });
+
+          expect(mobileAppLink().length).to.equal(0);
+        });
       });
 
       describe('logged-in user is not current patient targeted for viewing', () => {
diff --git a/test/unit/utils/utils.test.js b/test/unit/utils/utils.test.js
index ebe476aa2b..3aa2123da9 100644
--- a/test/unit/utils/utils.test.js
+++ b/test/unit/utils/utils.test.js
@@ -172,6 +172,44 @@ describe('utils', () => {
     });
   });
 
+  describe('getMobilePlatform', () => {
+    it('returns the platform for mobile devices, and null otherwise', () => {
+      _.each(Object.values(USER_AGENTS), userAgent => {
+        Object.defineProperty(window.navigator, 'userAgent', { value: userAgent, configurable: true });
+
+        switch(userAgent) {
+          case USER_AGENTS.chromeIPad:
+          case USER_AGENTS.chromeIPhone:
+          case USER_AGENTS.edgeIPhone:
+          case USER_AGENTS.safariIPhone:
+          case USER_AGENTS.safariIPad:
+          case USER_AGENTS.firefoxIPhone:
+            expect(utils.getMobilePlatform()).to.equal('ios');
+            break;
+
+          case USER_AGENTS.chromeAndroid:
+          case USER_AGENTS.edgeAndroid:
+          case USER_AGENTS.firefoxAndroid:
+            expect(utils.getMobilePlatform()).to.equal('android');
+            break;
+
+          case USER_AGENTS.chromeWin:
+          case USER_AGENTS.chromeMac:
+          case USER_AGENTS.edgeWin:
+          case USER_AGENTS.edgeMac:
+          case USER_AGENTS.firefoxWin:
+          case USER_AGENTS.firefoxMac:
+          case USER_AGENTS.safariMac:
+            expect(utils.getMobilePlatform()).to.be.null;
+            break;
+
+          default:
+            throw new Error('Each string in USER_AGENTS should have an expected result in the test');
+        }
+      });
+    });
+  });
+
   describe('validateEmail', () => {
     it('should validate jane@tidepool.org as email', () => {
       expect(utils.validateEmail('jane@tidepool.org')).to.be.true;
diff --git a/webpack.config.js b/webpack.config.js
index 22c8693e20..0142b24179 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -251,6 +251,16 @@ module.exports = {
   devServer: {
     static: { publicPath: output.publicPath },
     historyApiFallback: true,
+    // Mirrors the production route in server.js: the extensionless association file needs an
+    // explicit application/json type, and must not fall through to historyApiFallback.
+    setupMiddlewares: (middlewares, devServer) => {
+      devServer.app.get('/.well-known/apple-app-site-association', (req, res) => {
+        res.type('application/json');
+        res.sendFile(path.join(__dirname, 'static/.well-known/apple-app-site-association'));
+      });
+
+      return middlewares;
+    },
     hot: isDev,
     client: {
       logging: 'info',