One Public Surface: Server Components, Passkeys, and a WebView Shell
React Server Components on Lambda Web Functions as the one surface clients call: team-owned services behind token propagation, server-side passkeys, and a WebView shell.
A web app and a mobile app on AWS usually get two public surfaces. The browser calls a BFF with a session cookie, and the phone calls an API with a bearer token. Every authorization rule, rate limit, and schema change then lands twice, and the second surface gets the least review. Removing it only works if the mobile app can reuse the first surface for everything, sign-in included. A WebView does not get WebAuthn by default on either platform. In this build, React Server Components page servers on Lambda Web Functions, behind one CloudFront domain, are the only thing a client talks to. Each team’s data sits behind its own service, which the team’s page server calls with the user’s token. The Cognito passkey ceremony runs server-side, and a React Native WebView shell reuses all of it on iOS and Android. The sections below follow that boundary through data access, sign-in, the session, and the shell. They then list where it moves: the service endpoints, platform attestation, the CSRF origin check behind a TLS-terminating proxy, and per-client chrome.
Correction. The first version of this post described a narrower boundary. Each page server read its own DynamoDB table directly, no function called another, and nothing behind the page server had an address. The demo has since split every vertical into a web app and a service, so a team can own its data without sharing a table with its page code. That reverses three claims the first version made. The app now calls its service synchronously over HTTPS. The service has an endpoint of its own: its domain is on the internet, and Lambda accepts only requests signed by the owning app’s role. And the function-to-function cost the first version listed as a reason to avoid the hop is now paid on every page that reads data. The sections below describe the current build and say where the old claims no longer hold.
The stack is React Router 8.5.1 in RSC Framework Mode on Lambda Web Functions behind CloudFront, plus a Cognito user pool with passkeys as a first factor. RSC support is experimental, so pin exact versions. Every function runs Hono on Node 24. The shell is Expo SDK 58 / React Native 0.88 on react-native-webview 14.0.1, patched below with patch-package, so keep it at that exact version in the lockfile as well. The hosting half (the entry shim, NODE_ENV, streaming, the CloudFront hop and its latency numbers) is in the predecessor post. The Web Functions resource model is in the Hono lambdalith post. The code, the CDK app, the pipeline, and the WebView patch are in ayhansipahi/rsc-mfe-demo (opens in new tab); every snippet below is quoted from it. The demo runs at rscmfe.sph.sh (opens in new tab), where anyone can create an account, and the iOS shell is on the App Store as RSC Shell (opens in new tab).
The field has three standing answers for the phone. An API with an SDK and bearer tokens (REST or GraphQL, Amplify on the device) wins on offline writes, native UI on most screens, and partners who consume the API anyway. Hotwire Native and Capacitor-style shells share the shape used here, a native frame around web content. But they usually sit in front of a BFF or a monolith that also exposes a public API. Client-side micro-frontends (module federation, single-spa) compose in the browser, so every fragment needs an API and the boundary question multiplies.
The Boundary in One Diagram#
The browser and the shell send every request with the session cookie to CloudFront, which routes by path: /orders* to the orders app, /store* to the store app, /shell* to the shell’s fragments, everything else to the account app. The orders app signs a request to the orders service with its own role and forwards the user’s access token; the service verifies the token and queries its table keyed by its sub. For sign-in the account app calls Cognito with AdminInitiateAuth and AdminRespondToAuthChallenge, which need its IAM credentials. The page calls navigator.credentials.get() against the platform authenticator and never leaves its origin. The diagram matters for the arrows it does not have: nothing from the client to Cognito, nothing from the client to a table or a service, and nothing from one team’s app to another team’s service. The middle box is the part the first version did not have. Clients never call it. Its endpoints have internet domains, but each accepts only requests signed by one app’s role.
A Vertical Is an App and a Service#
A team owns a vertical end to end: a web app under apps/, a service under services/, and the service’s table. CODEOWNERS maps each directory to its team, and the only import allowed across packages is the platform package @rsc-mfe/shell from an app. The orders app has no table access. It reads through the orders service and forwards the user’s token.
// apps/orders/app/orders.server.ts
// The orders app reads its data from the orders team's service, forwarding the user's access token (SigV4-signed: the service endpoint is IAM-only).
// No table access here: the service's role is the only thing that can Query the rows.
export async function listOrders(user: Pick<SessionUser, "token" | "flow">): Promise<Order[]> {
const r = await serviceFetch(
`${process.env.ORDERS_API_URL}/orders`,
// A service that accepts the connection and stalls must not hang the page: fail into the 502 below.
{ signal: AbortSignal.timeout(Number(process.env.SERVICE_TIMEOUT_MS ?? 5000)) },
user,
).catch(() => null);
if (!r?.ok) throw new Response("orders service unavailable", { status: 502 });
return (await r.json()) as Order[];
}
serviceFetch comes from the platform package. It sends the user’s access token in x-user-token and the request’s x-flow-id, and signs the request with SigV4 under the app function’s own role: service name lambda, and UNSIGNED-PAYLOAD as the body hash. The token cannot travel in Authorization, because that header carries the signature and Lambda removes it after validating it. Locally, or with DEV_SESSION set, the call goes out unsigned.
// shells/web/src/service-fetch.server.ts
export async function serviceFetch(
url: string,
init: { method?: string; signal?: AbortSignal },
user: Pick<SessionUser, "token" | "flow">,
): Promise<Response> {
const target = new URL(url);
const method = init.method ?? "GET";
const headers = serviceHeaders(user);
if (isLocalService(target) || process.env.DEV_SESSION) return fetch(url, { ...init, method, headers });
headers["x-amz-content-sha256"] = "UNSIGNED-PAYLOAD";
const signed = await getSigner().sign({
method,
protocol: target.protocol,
hostname: target.hostname,
port: target.port ? Number(target.port) : undefined,
path: target.pathname,
query: Object.fromEntries(target.searchParams),
headers: { host: target.host, ...headers },
});
return fetch(url, { ...init, method, headers: signed.headers });
}
The service verifies the token against the same pool and scopes the query to its sub. Services share no code, so each carries its own copy of these lines.
// services/orders/auth.js
// Takes the x-user-token header's value: the raw access token.
export async function verifyUserToken(token) {
if (!token) return null;
if (process.env.NODE_ENV === "development" && process.env.DEV_SESSION && token === "dev") return { sub: "dev" };
try {
const payload = await getVerifier().verify(token);
return { sub: payload.sub };
} catch {
return null;
}
}
The table, its one grant, and the endpoint’s auth type live in the service’s CDK stack. The service’s role holds dynamodb:Query on that table ARN, and no other role holds anything on it. The orders app’s stack grants its own role lambda:InvokeWebFunctionEndpoint on this endpoint’s ARN, and no other role gets it.
// services/orders/infra/stack.ts
const fn = new WebFunction(this, "Api", {
functionName: `${prefix(stage)}-orders-api`,
packageDir: "services/orders",
authType: "IamAuth",
environment: {
ORDERS_TABLE: table.tableName,
COGNITO_USER_POOL_ID: deps.userPoolId,
COGNITO_CLIENT_ID: deps.clientId,
},
});
fn.role.addToPolicy(new iam.PolicyStatement({ actions: ["dynamodb:Query"], resources: [table.tableArn] }));
What this buys: the client still talks to one set of routes on one domain, and there is still one place where a user’s identity turns into a data query, the service. “One public surface” now means one surface that clients are built against, not one internet-reachable endpoint. The key condition on sub is the object-level check, since a query only returns rows under the caller’s own partition key. Any finer rule (a shared order, a support role) would be written into the service. Object-level authorization covers what those checks look like.
What it costs, and where the first version was right. The Lambda Developer Guide, under the heading “Anti-patterns in Lambda-based event-driven applications”, says: “Lambda functions directly calling other Lambda functions is generally an anti-pattern due to cost and complexity concerns”. The first version used that sentence to reject a private service behind the page server. An HTTPS call to another web function is the same shape: the app pays while it waits, the slower function bounds the page, and both need concurrency for the same peak. The demo pays that cost on purpose, for team ownership: the orders team can change its table, its access pattern, or its runtime without the orders app’s code knowing. AWS Prescriptive Guidance says synchronous calls, “in many cases, are the widely accepted standard for communication”, and lists predictable flow control and strong consistency among their benefits. A read that a page needs before it can render is that case. What the build does to contain the cost is in the code above: a timeout, a 502 instead of a hung page, and a flow id. Every function writes one JSON log line per request with that id, so one id in CloudWatch finds the page and the service calls behind it. Work that crosses teams, as opposed to a page reading its own team’s data, still belongs on events.
Passkeys With the Browser Kept Out of Cognito#
Sign-in is a WebAuthn ceremony, and both halves of it that touch Cognito run inside the account app’s function. The page talks to navigator.credentials and to /auth/passkey on its own origin; it never imports the Cognito SDK, never holds the client secret, and never sees the access token.
Cognito’s USER_AUTH flow is choice-based: the caller names a preferred challenge and Cognito answers with it or with the alternatives it can offer. apps/account/app/cognito.server.ts is the only module that imports the Cognito SDK. For sign-in it calls AdminInitiateAuth with WEB_AUTHN as the preferred challenge and later completes the challenge with AdminRespondToAuthChallenge and the assertion the page produced. Every call carries a SECRET_HASH, the HMAC-SHA256 of username plus client ID under the client secret.
// apps/account/app/cognito.server.ts
const UserPoolId = () => process.env.COGNITO_USER_POOL_ID!;
const ClientId = () => process.env.COGNITO_CLIENT_ID!;
// Cognito's proof that the caller holds the client secret: HMAC-SHA256(username + clientId, secret).
const secretHash = (username: string) =>
createHmac("sha256", process.env.COGNITO_CLIENT_SECRET!).update(username + ClientId()).digest("base64");
export async function passkeySignInStart(username: string) {
const r = await client().send(
new AdminInitiateAuthCommand({
UserPoolId: UserPoolId(),
ClientId: ClientId(),
AuthFlow: "USER_AUTH",
AuthParameters: { USERNAME: username, PREFERRED_CHALLENGE: "WEB_AUTHN", SECRET_HASH: secretHash(username) },
}),
);
if (r.ChallengeName !== "WEB_AUTHN" || !r.Session) throw new Error(`unexpected challenge ${r.ChallengeName}`);
return { session: r.Session, options: JSON.parse(r.ChallengeParameters!.CREDENTIAL_REQUEST_OPTIONS!) };
}
export async function passkeySignInFinish(username: string, session: string, credential: unknown) {
const r = await client().send(
new AdminRespondToAuthChallengeCommand({
UserPoolId: UserPoolId(),
ClientId: ClientId(),
ChallengeName: "WEB_AUTHN",
Session: session,
ChallengeResponses: { USERNAME: username, CREDENTIAL: JSON.stringify(credential), SECRET_HASH: secretHash(username) },
}),
);
return tokenOf(r);
}
InitiateAuth and RespondToAuthChallenge, the public pair, are unauthenticated operations: anyone who learns the client ID can start a sign-in from the internet, and a client ID is not a secret. The Admin pair needs IAM credentials, so the sign-in entry point is the account app’s role. The account stack grants cognito-idp:AdminInitiateAuth and cognito-idp:AdminRespondToAuthChallenge on the pool ARN to that role and to no other. An early cut used the public pair with a public client and kept the client ID on the server. That hid the entry point and nothing more, since the pool’s sign-in API stayed open to anyone with the ID.
Registration needs a signed-in user, so it runs on the access token from the cookie. StartWebAuthnRegistration returns CredentialCreationOptions, the page runs startRegistration({ optionsJSON }) from @simplewebauthn/browser, and CompleteWebAuthnRegistration stores the result.
// apps/account/app/cognito.server.ts
export async function passkeyRegisterStart(accessToken: string) {
const r = await client().send(new StartWebAuthnRegistrationCommand({ AccessToken: accessToken }));
return r.CredentialCreationOptions;
}
export async function passkeyRegisterFinish(accessToken: string, credential: unknown) {
await client().send(new CompleteWebAuthnRegistrationCommand({ AccessToken: accessToken, Credential: credential as never }));
}
One resource route carries the four intents. It answers every call with Cache-Control: private, no-store, and on signin-finish it sets two cookies: the session cookie from the access token, and a last_email cookie scoped to /login. The login page reads the second one to offer the last account a passkey sign-in, since Cognito’s passkey sign-in starts from a username; it holds no credential.
// apps/account/app/routes/auth.passkey.ts
export async function action({ request }: { request: Request }) {
const body = await request.json().catch(() => ({}));
try {
switch (body.intent) {
case "signin-start":
return Response.json(await passkeySignInStart(String(body.email)), { headers: noStore });
case "signin-finish": {
const token = await passkeySignInFinish(String(body.email), String(body.session), body.credential);
return new Response(null, { status: 204, headers: signInCookies(token, String(body.email), new Headers(noStore)) });
}
case "register-start": {
const user = await getUser(request);
if (!user) return new Response("unauthorized", { status: 401 });
return Response.json({ options: await passkeyRegisterStart(user.token) }, { headers: noStore });
}
case "register-finish": {
const user = await getUser(request);
if (!user) return new Response("unauthorized", { status: 401 });
await passkeyRegisterFinish(user.token, body.credential);
return new Response(null, { status: 204, headers: noStore });
}
default:
return new Response("unknown intent", { status: 400 });
}
} catch (e) {
// Cognito's message is fine for a demo; a product would map these.
return new Response(e instanceof Error ? e.message : "auth failed", { status: 400, headers: noStore });
}
}
The pool is part of the account team’s CDK stack. It runs on the Essentials tier, since passkeys and USER_AUTH need the Essentials or Plus plan, with password and passkey as first factors and the public domain as the relying party ID. The client is confidential: generateSecret: true, with only the USER_AUTH flow enabled. Password sign-in uses the same USER_AUTH flow with PREFERRED_CHALLENGE: PASSWORD, so the login page offers both buttons on one form. Sign-up is open, and Cognito confirms the email with a code before the new account can sign in.
// apps/account/infra/stack.ts
const pool = new cognito.UserPool(this, "Pool", {
userPoolName: `${prefix(stage)}-users`,
featurePlan: cognito.FeaturePlan.ESSENTIALS,
selfSignUpEnabled: true,
autoVerify: { email: true },
// ...password policy...
signInPolicy: { allowedFirstAuthFactors: { password: true, passkey: domain !== undefined } },
...(domain && {
passkeyRelyingPartyId: domain.name,
passkeyUserVerification: cognito.PasskeyUserVerification.REQUIRED,
}),
removalPolicy: RemovalPolicy.RETAIN,
});
// Confidential client: the secret stays in the web function's environment.
const client = pool.addClient("Web", {
userPoolClientName: "web-confidential",
generateSecret: true,
disableOAuth: true,
authFlows: { user: true },
authSessionValidity: Duration.minutes(15),
});
Passkeys are tied to the stage’s domain. A stage without one, such as staging on its CloudFront address, gets password sign-in only.
The boundary depends on what stays on the server: the client secret, the IAM credentials the Admin calls need, and the access token never reach the page. The one value that does round-trip is Cognito’s challenge Session string, returned by signin-start and posted back unchanged by signin-finish. It is opaque, single-use, and tied to this one pending challenge. A replay would need a SECRET_HASH, which only the client secret can produce, and the page never has that secret. On the Admin path the IAM credentials are a second layer on top. The client ends up holding a credential it cannot export and a cookie it cannot read.
The Session Cookie and Its Ceiling#
The session is the Cognito access token in an HttpOnly; Secure; SameSite=Lax cookie, verified on every request against the pool’s JWKS with aws-jwt-verify. There is no session store, so every function stays stateless, and page JavaScript cannot read the token because of HttpOnly. getUser lives in the platform package, so every app verifies the session the same way and carries no auth code of its own. The same token is what an app forwards to its service.
// shells/web/src/session.server.ts
const getVerifier = () =>
(verifier ??= CognitoJwtVerifier.create({
userPoolId: process.env.COGNITO_USER_POOL_ID!,
clientId: process.env.COGNITO_CLIENT_ID!,
tokenUse: "access",
}));
// Platform contract + local stub: a vertical running on its own has no account app to sign in
// with, so outside production DEV_SESSION names the user. Production builds never read it.
export async function getUser(request: Request): Promise<SessionUser | null> {
const flow = request.headers.get("x-flow-id") ?? undefined;
if (process.env.NODE_ENV !== "production" && process.env.DEV_SESSION) {
return { sub: "dev", username: process.env.DEV_SESSION, token: "dev", ...(flow && { flow }) };
}
const token = readCookie(request);
if (!token) return null;
try {
const payload = await getVerifier().verify(token);
return { sub: payload.sub, username: String(payload.username), token, ...(flow && { flow }) };
} catch {
return null;
}
}
export const sessionCookie = (token: string) =>
`${COOKIE}=${token}; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=3600`;
export const clearedCookie = `${COOKIE}=; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=0`;
DEV_SESSION lets one team run its app and its service on a laptop without the account app. The service accepts the token dev only when NODE_ENV is development and DEV_SESSION is set. The check is opt-in rather than “not production”, because Lambda does not set NODE_ENV.
The demo keeps the access token as the whole session. Max-Age=3600 matches the one-hour default access-token lifetime, the demo discards the refresh token Cognito returns, there is no revocation list, and sign-out clears the cookie and nothing else. A production build would add one of two things. The first is that refresh token in a second HttpOnly cookie, with a /session/refresh action that exchanges it before the hour runs out. The second is an opaque session ID backed by DynamoDB, which makes revocation a delete and keeps tokens off the wire. The second option also changes token propagation: the app would look up a token, or mint a narrower one, before it calls a service. Both keep the boundary as drawn, because both run inside the page server.
The Mobile Shell#
The shell is one Expo app with one file of product-relevant code, shells/mobile/shell.tsx; the app/ directory holds one-line route files that re-export its Page and its layout. The native layer owns the frame: the system tab bar through expo-router’s NativeTabs, safe-area insets from react-native-safe-area-context, and one WebView per tab pinned to the one origin. It has no API client and no token. The file did not change when the web side split into apps and services: the tabs load paths, and which function answers a path is CloudFront’s business. The excerpt below leaves out the Face ID lock, the camera hand-off, and the message handling; the full file is in the repo (opens in new tab).
// shells/mobile/shell.tsx
// The product UI is the web function's pages. The shell owns the frame: the system tab bar (expo-router
// NativeTabs, a UITabBarController, so Liquid Glass on iOS 26+), one WebView per tab pinned to the
// origin, all tabs on WebKit's one default cookie store. No API client, no token: the session cookie is
// born inside the WebView, and the native layer only picks URLs. Not sharedCookiesEnabled: it copies
// cookies into the app's native jar but never deletes them there, then seeds every new WebView from
// that jar, so a signed-out session returns.
// The pages tell the shell UI state (signed in or not, cart count) over postMessage, never a token.
// Two native capabilities sit on top. A Face ID lock on launch and on return from the background: it
// gates the screen, not the session; signing in stays the page's passkey ceremony. And the camera:
// the Store tab's accessory takes a photo and hands it to the page, which owns the search call.
// app/ holds one route file per tab; each re-exports Page or this layout.
// ...
// The tab bar is the shell's auth UI. Signed out, the tabs that need a session are not in the bar
// and a Sign in tab is, so no tab ever opens on a login page. Signed in, that slot is the Account
// tab: the account vertical's page with passkeys and sign out.
const tabs: Tab[] = [
{ name: "index", label: "Home", path: "/", icon: { sf: { default: "house", selected: "house.fill" }, md: "home" } },
{ name: "store", label: "Store", path: "/store", icon: { sf: { default: "storefront", selected: "storefront.fill" }, md: "storefront" } },
{ name: "cart", label: "Cart", path: "/store/cart", icon: { sf: { default: "cart", selected: "cart.fill" }, md: "shopping_cart" }, auth: true },
{ name: "orders", label: "Orders", path: "/orders", icon: { sf: { default: "shippingbox", selected: "shippingbox.fill" }, md: "package_2" }, auth: true },
{ name: "account", label: "Account", path: "/account", icon: { sf: { default: "person.crop.circle", selected: "person.crop.circle.fill" }, md: "account_circle" }, auth: true },
{ name: "signin", label: "Sign in", path: "/login?next=/store", icon: { sf: "person.crop.circle", md: "login" }, auth: false },
];
// ...
// One tab's screen: a WebView on its path. Each tab keeps its own history and scroll, like native
// stacks. The page runs under the glass bar; automatic insets keep its last row scrollable above it.
export function Page() {
const shell = use(Shell)!;
const { name } = useRoute();
const tab = tabs.find((t) => t.name === name)!;
const top = useSafeAreaInsets().top;
const seen = useRef(false);
useFocusEffect(
useCallback(() => {
// The cart page is server-rendered; adds from the Store tab happened in another WebView.
// A page-side reload, not WebView.reload(): that one shows the library's white loading view.
if (name === "cart" && seen.current) shell.views.cart?.injectJavaScript("location.reload();true;");
seen.current = true;
}, [name, shell]),
);
return (
<View style={{ flex: 1, paddingTop: top, backgroundColor: shell.bg }}>
<WebView
ref={(view) => {
shell.views[name] = view;
}}
// The page paints its own theme through prefers-color-scheme; this only covers the frames
// before the first paint, which would otherwise flash white in dark mode.
style={{ flex: 1, backgroundColor: shell.bg }}
source={{ uri: `${ORIGIN}${tab.path}` }}
applicationNameForUserAgent={SHELL_UA}
allowsBackForwardNavigationGestures
contentInsetAdjustmentBehavior="automatic"
onMessage={shell.onMessage}
// Anything off-origin would leave the product; keep it inside the shell's one domain.
// Compare origins, not prefixes: a startsWith check also matches look-alike hosts.
onShouldStartLoadWithRequest={(req) => new URL(req.url).origin === ORIGIN}
/>
</View>
);
}
// ...
<NativeTabs tintColor={tint}>
{/* ... */}
{signedIn && pathname === "/store" && (
<NativeTabs.BottomAccessory>
<Pressable onPress={photoSearch} accessibilityLabel="Search with a photo" style={styles.accessory}>
<Ionicons name="camera-outline" size={20} color={theme.active} />
<Text style={{ color: theme.active, fontSize: 15 }}>Search with a photo</Text>
</Pressable>
</NativeTabs.BottomAccessory>
)}
{tabs.map((tab) => (
<NativeTabs.Trigger key={tab.name} name={tab.name} hidden={tab.auth !== undefined && tab.auth !== signedIn}>
<NativeTabs.Trigger.Icon {...tab.icon} />
<NativeTabs.Trigger.Label>{tab.label}</NativeTabs.Trigger.Label>
{tab.name === "cart" && cartCount > 0 && <NativeTabs.Trigger.Badge>{String(cartCount)}</NativeTabs.Trigger.Badge>}
</NativeTabs.Trigger>
))}
</NativeTabs>
Three decisions carry the design. The first is one WebView per tab, so each tab keeps its own history and scroll position. allowsBackForwardNavigationGestures gives each tab the iOS swipe-back; the prop is iOS and macOS only, so Android would need a BackHandler that calls goBack(). Cookies are shared through the default WKWebsiteDataStore on iOS and the process-wide CookieManager on Android, so the session stays one session. That is also why the shell leaves sharedCookiesEnabled off. In react-native-webview 14 on iOS, the prop copies WebView cookies into the app’s NSHTTPCookieStorage but never deletes them there, and it seeds every new WebView from that store. After a sign-out, a newly mounted tab gets the old session cookie back. The second is that the tab bar is the system’s. NativeTabs is backed by a UITabBarController, so iOS 26 and later draw the bar in Liquid Glass with the page running underneath, and contentInsetAdjustmentBehavior="automatic" keeps the page’s last row scrollable above the bar. Tabs that need a session are hidden without one, and NativeTabs remounts its tab view whenever the set of visible tabs changes. A sign-in or sign-out therefore reloads every tab, and no page keeps rendering the old session. One system behavior did not carry over: with minimizeBehavior="onScrollDown", the bar did not shrink while a WebView scrolled, so the shell leaves it off. The third is that the native layer never holds a token. The session cookie comes from the account app’s Set-Cookie inside the WebView, and it survived an app kill and relaunch on both platforms.
Two native capabilities sit on the frame, to show that native code can grow next to the WebViews without moving the boundary. A Face ID lock covers the screen on launch and on every return from the background while a session exists. It gates the screen, not the session; signing in stays the page’s passkey ceremony. On the Store tab, the tab bar’s bottom accessory opens the camera. The shell resizes the photo and dispatches it into the page as a shell:photo event, and the store app’s page sends it to its own route, which asks a Bedrock model to match it against the catalog. The shell gains no API client: the search endpoint, its session check, and its result page stay in the vertical and change without an app release.
applicationNameForUserAgent appends RSCShell/1 to the User-Agent; the next section shows what the server does with that.
Hotwire Native is the field’s name for a native frame around web content. What differs here is that the page servers are the BFF, clients call nothing else, and sign-in needs no bridge. RSC does not draw that boundary. Any server-rendered framework that reads its data on the server draws the same one. RSC’s part is narrower: the data call lives in server components, with no client-side API layer between it and the page.
What App Review Asked For#
The shell passed App Review and is listed in the Shopping category. Two things in the repo exist because of review. The first is account deletion. Guideline 5.1.1(v) says apps that support account creation must also let users delete their account in the app. The deletion lives where the rest of the account lives: a disclosure on the account app’s /account page that calls Cognito’s DeleteUser with the user’s access token and then clears the session the way /logout does. The shell needed no change, because the account tab is that page.
// apps/account/app/cognito.server.ts
// App Store guideline 5.1.1(v): an app that creates accounts must let the user delete them.
// ponytail: deletes the Cognito user only; rows in the orders and cart tables stay keyed by a sub
// that no longer exists. Wipe them here if a client ever asks for it.
export async function deleteAccount(accessToken: string) {
await client().send(new DeleteUserCommand({ AccessToken: accessToken }));
}
The comment names the gap. With data split across team-owned services, deleting an account is a cross-team operation, and the only part the account team owns is the identity. A product build would publish an account-deleted event that each service consumes for its own table, which is the asynchronous path the first section points at for work that crosses teams.
The second is the answer to a guideline 2.1 information request: the purpose and audience of the app, a demo account, and a written walk-through of the flow, kept in docs/app-store/review-notes.txt. The privacy and support URLs the listing needs are two more routes on the account app, /privacy and /support, so they ship with the same pipeline as the rest of the site. The privacy label lists one data type, the email address, used for app functionality. One approval is one data point about guideline 4.2, not a rule; the decision table at the end keeps that row hedged.
Per-Client Chrome From the Server#
Browsers get a web header and footer; the shell gets neither, since it has the system tab bar. The decision is made on the server from the User-Agent token, in the platform package’s Page component that every app’s root renders. Each app’s root loader reads the token and passes it in.
// apps/orders/app/root.tsx
export async function loader({ request }: Route.LoaderArgs) {
return {
// Who is signed in and the cart count, so the header's server HTML is not bare.
...(await chrome(request)),
shell: (request.headers.get("user-agent") ?? "").includes("RSCShell/"),
stitch: new URL(request.url).searchParams.has("stitch"),
// Where the shell's header and footer scripts come from: "" on the shared host, a dev server
// when this app runs on its own, unset for a page with empty slots.
shellOrigin: process.env.SHELL_ORIGIN ?? "",
};
}
// The User-Agent does not change between navigations and active links are computed on the client,
// so a link click does not need the root loader again. Form submits still revalidate.
export function shouldRevalidate({ formMethod, defaultShouldRevalidate }: ShouldRevalidateFunctionArgs) {
return formMethod ? defaultShouldRevalidate : false;
}
Page draws three areas: <rsc-header>, the app’s <main>, and <rsc-footer>. The header and footer are web components that the shell function serves from /shell-static/fragments/. A shell deploy therefore changes the chrome on every page without rebuilding an app, and an app deploy changes only its own main. Inside the mobile shell, Page skips both and turns off pinch zoom.
// shells/web/src/layout.tsx
export function Page({ shell, owner, build, shellOrigin, stitch, email, cartCount, children }: PageProps) {
return (
<>
<meta name="viewport" content={shell ? shellViewport : viewport} />
{stitch && <Stitch />}
{shell ? (
<>
{/* The fragments draw nothing here; they report the session and the cart count to the
native tab bar. Each script comes from the team that owns it. */}
<script type="module" src="/fragments/account-button.js" async />
<script type="module" src="/store-static/fragments/mini-cart.js" async />
<div hidden>
<rsc-account-button />
<rsc-mini-cart />
</div>
</>
) : (
<>
<link rel="stylesheet" href={`${shellOrigin}/shell-static/fragments/chrome.css`} precedence="default" />
<script type="module" src={`${shellOrigin}/shell-static/fragments/header.js`} async />
<script type="module" src={`${shellOrigin}/shell-static/fragments/footer.js`} async />
{/* ... */}
<rsc-header data-owner="shell">
<nav>
{pages.map(([to, label]) => (
<a key={to} href={to}>
{label}
</a>
))}
<span>
<a href="/store/cart">Cart{cartCount != null && <span>{cartCount}</span>}</a>
{email ? <a href="/account">{email}</a> : <a href="/login">Sign in</a>}
</span>
</nav>
</rsc-header>
</>
)}
<main data-owner={owner} data-build={build} className="mx-auto w-full max-w-3xl space-y-4 p-6">
{children}
</main>
{!shell && (
<rsc-footer data-owner="shell">
<footer>RSC micro-frontend demo</footer>
</rsc-footer>
)}
</>
);
}
Every <rsc-*> tag ships with server HTML inside it: the nav links, the cart and sign-in links, the footer line. Crawlers and users who have not loaded the script yet get that markup; the fragment’s shadow root covers it once it runs. Anything that must be indexed stays in the page owner’s server render, and fragments only add what they own on top. Inside the shell, the account button and the mini cart still load, each from the team that owns it, but they render hidden and report the session and the cart count to the native tab bar.
The header’s cart count adds a hop. chrome(request) reads it from the store’s published contract, /store/api/cart, through the public host with the request’s cookie forwarded. On an orders page that is a call from the orders app to the store app through CloudFront. It is best effort: capped at 1.5 seconds, and a slow or absent store leaves the count out, never the page. Add ?stitch to any URL to outline each area with its owner and build stamp.
The account app’s home route cannot be prerendered: a static index.html would reach the shell with the web chrome, so react-router.config.ts in each app is empty. The distribution’s page cache policy has a default TTL of 0, which keeps the two variants apart. A distribution that caches pages needs the User-Agent token in its cache key.
Associated Domains on iOS#
For the passkey ceremony to run inside the WebView on iOS (the App Store build requires iOS 16.4 or later), the app and the domain have to vouch for each other. The app side is one entry in app.json.
"ios": {
"bundleIdentifier": "sh.sph.rscmfe",
"appleTeamId": "3EWL9B9GPV",
"supportsTablet": false,
"associatedDomains": ["webcredentials:rscmfe.sph.sh"]
}
Development builds added ?mode=developer to the domain. Per Apple’s entitlement page, that suffix applies only on devices in developer mode, to apps signed with a development profile, after the user opts in. The App Store build drops it. The domain side is the apple-app-site-association file. The account app serves it from an environment variable that the prod stage sets, so the relying party ID, the WebView origin, and the associated domain are one hostname.
// apps/account/index.js
// App-to-domain association for passkeys in the mobile shell. Served from here so the RP ID,
// the WebView origin and the associated domain are one hostname.
const appleAppIds = (process.env.APPLE_APP_IDS ?? "").split(",").filter(Boolean);
app.get("/.well-known/apple-app-site-association", (c) => c.json({ webcredentials: { apps: appleAppIds } }));
Each value is a Team ID and the bundle identifier joined with a dot; the prod stage lists one per signing team. Nothing else was needed: no WKWebView configuration beyond react-native-webview’s defaults and no native module.
In the shell, tapping the registration button on /account produced the system “Save a passkey?” sheet, which named the app and its place in Passwords. Face ID followed, then the page status “Passkey saved. Sign out and sign in with it.” After sign-out, the passkey button on the login page produced the sheet “Sign in to “RSC Shell” with your passkey for “demo@example.com”?”. Face ID followed, then the signed-in page. The sheet names the app while the credential is bound to the domain, so the user sees one identity in Safari and in the app.
The Android WebView Setting Behind a Patch#
Android WebView ships with WebAuthn off. An app opts in with WebSettingsCompat.setWebAuthenticationSupport(settings, WEB_AUTHENTICATION_SUPPORT_FOR_APP) from androidx.webkit, behind a WebViewFeature.isFeatureSupported(WEB_AUTHENTICATION) check. react-native-webview 14.0.1 has no prop for it, so the shell adds the guarded call to RNCWebViewManagerImpl.kt with patch-package. The diff is the whole fix.
--- a/node_modules/react-native-webview/android/src/main/java/com/reactnativecommunity/webview/RNCWebViewManagerImpl.kt
+++ b/node_modules/react-native-webview/android/src/main/java/com/reactnativecommunity/webview/RNCWebViewManagerImpl.kt
@@ -82,6 +82,11 @@ class RNCWebViewManagerImpl(private val newArch: Boolean = false) {
settings.allowFileAccessFromFileURLs = false
settings.allowUniversalAccessFromFileURLs = false
settings.mixedContentMode = WebSettings.MIXED_CONTENT_NEVER_ALLOW
+ // Passkeys inside the WebView: Credential Manager answers navigator.credentials for origins
+ // this app is linked to through assetlinks.json (androidx.webkit 1.12+, gated at runtime by isFeatureSupported).
+ if (WebViewFeature.isFeatureSupported(WebViewFeature.WEB_AUTHENTICATION)) {
+ WebSettingsCompat.setWebAuthenticationSupport(settings, WebSettingsCompat.WEB_AUTHENTICATION_SUPPORT_FOR_APP)
+ }
// Fixes broken full-screen modals/galleries due to body height being 0.
webView.layoutParams = ViewGroup.LayoutParams(
The domain side is assetlinks.json, served by the account app next to the Apple file. It lists the package name and the signing certificate’s SHA-256 under the get_login_creds and handle_all_urls relations. Android’s WebView passkey guide requires the app to be associated with the site through Digital Asset Links. Only the positive path was run, with the file in place.
// apps/account/index.js
const androidPackage = process.env.ANDROID_PACKAGE;
const androidCertShas = (process.env.ANDROID_CERT_SHA256 ?? "").split(",").filter(Boolean);
app.get("/.well-known/assetlinks.json", (c) =>
c.json(
androidPackage
? [{ relation: ["delegate_permission/common.get_login_creds", "delegate_permission/common.handle_all_urls"], target: { namespace: "android_app", package_name: androidPackage, sha256_cert_fingerprints: androidCertShas } }]
: [],
),
);
With both in place the logcat line CredentialManager: starting executeCreateCredential with callingPackage: sh.sph.rscmfe appeared, followed by the system sheet “Create passkey on another device?” listing demo@example.com. On the emulator, which had no Google account, the only provider was the hybrid QR flow, so the local ceremony stopped at the sheet. A device with Google Password Manager signed in would offer it as the local provider. Cancelling returns NotAllowedError to the page, and a wrong setting produces the same error. The logcat line is therefore the thing to check when the sheet does not appear. The Android shell is not in a store; it was verified on an emulator build.
One layout detail belongs here. React Native 0.88 draws edge-to-edge, and the core SafeAreaView is iOS-only and deprecated. A WebView without react-native-safe-area-context therefore sits under the status bar, and taps on the page’s top row land there instead. Page in shell.tsx pads its top by useSafeAreaInsets().top, which keeps the page below it.
The Vertical Split in Practice#
The split is not new. IKEA’s M2 mobile web project gave a team “responsibility for a set of pages and/or fragments” and stitched them at the edge; Gustaf Nilsson Kotte, a consultant working with IKEA on M2, called Edge Side Includes “the core technology that we have found to be really useful for our services.” Zalando’s Project Mosaic composed pages on the server from fragments “owned by different teams”, through its Tailor layout service. Zalando later moved most traffic to Interface Framework, where one Rendering Engine “stitches it all together and streams the HTML to the client”. That is one platform rendering many teams’ components, closer to the shared @rsc-mfe/shell package than to separate builds. Spotify’s desktop client is the client-side counterexample: per-team views isolated in iframes let teams release on their own, until “the architecture of isolated views was difficult to maintain” and the web player moved to one React codebase shared across views. Amazon’s retail site is often named in this list, but its public sources describe a rendering engine that sends requests “to over 150 services” for one page: many backend services behind one renderer, not team-owned pages. What this build adds to the IKEA and Mosaic shape is a mobile shell that reuses the same pages, and React Server Components in place of HTML fragments.
Route-based micro-frontends on this base, the single-app relative of server-side composition, are a CloudFront routing decision plus a few build-time facts. The repository has three layers:
| Directory | Owner | What it holds |
|---|---|---|
shells/web | platform | @rsc-mfe/shell: page skeleton, session contract, header and footer fragments, CloudFront |
shells/mobile | platform | The Expo app: native tab bar around the teams’ pages |
apps/account | account | /, /login, /signup, /logout, /account, /privacy, /support, /auth/*, the well-known files, <rsc-account-button> |
apps/orders | orders | /orders |
apps/store | store | /store, /store/cart, /store/api/*, <rsc-mini-cart> |
services/orders | orders | GET /orders and the orders table |
services/cart | store | GET /cart, PUT and DELETE /cart/:id, and the carts table |
Every package has its own package.json, index.js, and infra/stack.ts. Each app is its own React Router build with its own route file; the orders app’s is one line. The orders function answers / with 404 and the account function answers /orders with 404; CloudFront is what makes them look like one site.
Assets are the second build-time fact. Two builds cannot share one hashed-asset namespace behind one domain, since /assets/* already belongs to the account app. The orders build sets its Vite base to /orders-static/ and the store build uses /store-static/. Hashed client assets go to one S3 bucket and are never pruned, so the HTML of any revision still finds its files during a rollout. The functions keep a fallback copy that nobody should hit.
The CloudFront side is the platform team’s edge stack. Order is load-bearing: CloudFront takes the first pattern that matches, and /orders* would also match /orders-static/.
// shells/web/infra/edge-stack.ts
this.distribution = new cloudfront.Distribution(this, "Distribution", {
defaultBehavior: page(account),
// Order matters: more specific patterns first, as on the live distribution.
additionalBehaviors: {
"/orders-static/assets/*": bucketStatic,
"/store-static/assets/*": bucketStatic,
"/shell-static/*": functionStatic(shell),
"/shell*": page(shell),
"/store-static/*": functionStatic(store),
"/store*": page(store),
"/orders-static/*": functionStatic(orders),
"/orders*": page(orders),
"/assets/*": bucketStatic,
},
// ...
});
The services have no behavior here. Their apps reach them with signed requests at their own endpoint hostnames, passed in as ORDERS_API_URL and CART_API_URL.
The third fact is that links leave an app as document loads. An RSC tree does not cross a function: a client-side navigation from the orders build to / would ask the account function for a payload the orders client cannot render. The header’s nav is plain <a> tags drawn by the shell’s fragment, so every cross-app link is a full document load. Sign-out, passkey registration, and account deletion live on /account, next to the code that issues the session.
Permissions follow the split, and each grant sits in the stack of the team that owns the resource:
| Function | Grants beyond logs |
|---|---|
| account app | cognito-idp:AdminInitiateAuth and AdminRespondToAuthChallenge on the pool |
| orders app | lambda:InvokeWebFunctionEndpoint on the orders service endpoint |
| orders service | dynamodb:Query on the orders table |
| store app | lambda:InvokeWebFunctionEndpoint on the cart service endpoint, and bedrock:InvokeModel on one Claude Haiku inference profile and the model it routes to in EU Regions, for photo search |
| cart service | dynamodb:Query, UpdateItem, DeleteItem on the carts table |
| shell | none |
The orders app cannot read orders even if its code tried; it can only ask the orders service for the signed-in user’s rows. The account app cannot read either table, and no function but the account app can start a sign-in.
Deployment is one CDK app and one pipeline. A pull request runs typecheck, tests, cdk synth, and a cdk diff against staging and prod with a read-only role. A merge to main builds once, deploys staging, then waits for a reviewer before deploying the same build to prod. GitHub Actions assumes the deploy roles over OIDC, and developers have read-only AWS access. Each stage deploys through its own execution role, with a permissions boundary on every role its stacks create. The stages share the code and differ only in infra/stages.ts.
Every response carries x-vertical, naming the function that answered, and x-flow-id, minted by the first function a request reaches and forwarded to services.
One cross-app artifact appeared. React Router’s route-discovery request, GET /.manifest?paths=...&version=<build>, is not path-prefixed. The orders client’s manifest call therefore lands on the account function and gets a 204 for a build version it does not know. With document-load links the client did not need it. For a split that keeps client-side navigation across apps, routeDiscovery: { mode: "initial" } in react-router.config.ts turns discovery off. The documented manifestPath option does not help here: in RSC Framework Mode 8.5.1 the client builds the manifest URL from the path or the basename and does not read it.
The apps share exactly the boundary: the domain, the Cognito pool and the platform package’s verifier, the User-Agent rule for chrome, and the shell’s fragments. The session cookie reaches every app, and every app and service trusts the same token.
| Cost of the split | What it means in this build |
|---|---|
| Cross-app navigation | A full document load on every link that crosses an app |
| Data reads | One signed, synchronous HTTPS hop from app to service per read, with a 5-second timeout |
| Shared chrome | Fragments served at request time; a change to Page’s markup still rebuilds every app |
| Deployment | One stack per package, one pipeline for all of them |
| Cross-team writes | Account deletion reaches Cognito only; the tables need an event the services consume |
Where the Boundary Moves#
The ten entries below pair a symptom with its cause and fix; they are properties of the pattern, so they recur in other builds of it.
- Hydrated form POSTs return 400 while raw POSTs return 302. React Router 8.5 runs a CSRF check (
throwIfPotentialCSRFAttackin the 8.5.1 build output) before UI-route actions and compares theOriginheader withrequest.url. Resource routes are exempt, so/auth/passkeyrelies onSameSite=Laxplus a JSON body. Behind Lambda Web Functions the Node process seeshttp://and the endpoint hostname, so a real browser fails closed andcurlpasses. The fix in each app’sindex.jsrewrites the request URL tohttps://plusPUBLIC_HOSTbefore handing it to React Router; the documented alternative isallowedActionOriginsinreact-router.config.ts, which lists accepted origins without overriding the host. With the rewrite, browser POSTs sent straight to an endpoint hostname fail the check, and a stage without a domain cannot sign anyone in on its CloudFront address. This is the one place the single-surface claim touches the framework: the server has to know its public name. - A service endpoint answers anyone on the internet. An
ApplicationManagedendpoint runs the function for every request, and a valid access token reaches its owner’s rows without CloudFront in front, where edge rate limiting or a WAF would sit. The services in this build areIamAuth: Lambda rejects unsigned requests before the function runs, and only the owning app’s role holdslambda:InvokeWebFunctionEndpointon the endpoint. The domain itself stays on the internet. Lambda’s networking page saysIamAuth“does not make the endpoint private at the network layer”, and PrivateLink is not available for these domains. Lambda removes theAuthorizationheader after it validates a SigV4 signature, so the user’s token travels inx-user-token. The apps’ endpoints are stillApplicationManaged.IamAuthwith a CloudFront origin access control closes them too; CloudFront then signs every origin request and passes the viewer’sAuthorizationheader through, as the predecessor post covers. SwitchingAuthTypeupdates the endpoint in place, but one pipeline run flips the services before the apps start signing, so the orders and cart pages return 502 for the few minutes between those stacks. - A page hangs or fails when one service is slow. The synchronous hop bounds the page by the service. The apps cap each call with
AbortSignal.timeoutand turn a failure into a 502 from the loader. Grep the flow id from the page’s response in the service’s log group to see which side was slow. - The passkey sheet never appears on iOS. The promise rejects with
NotAllowedError. The associated domain is missing, the AASA file is not served, or it is served without the Team ID prefix. Fetch the file at the public domain first. - The same on Android, with no
CredentialManagerline in logcat. The WebView setting is off, which is the default. With the setting on but asset links wrong, the line appears and the sheet errors instead. - The second tab opens scrolled to the bottom.
display: "none"on the inactive WebView, in a shell that draws its own tab bar. Keep it laid out and hide it with opacity. With the system tab bar (NativeTabs), switching tabs did not reproduce it. - The home page shows the web chrome inside the shell. A prerendered
index.htmlwas served by the static middleware before the loader ran. Drop the prerender for routes whose chrome depends on the client. - The session ends after an hour. By design in the demo: the access token’s lifetime with no refresh. The upgrade path is in the session section.
- Passkey registration reports that the device has no provider (Android). No credential provider is installed or signed in. Google Password Manager needs a Google account, so the device state is the cause.
- A public Cognito client ID treated as a secret.
InitiateAuthis unauthenticated; keeping the client ID on the server hides the entry point and nothing more. The client secret is the boundary. WithALLOW_USER_AUTHthe public sign-in calls stay open to anyone who can compute aSECRET_HASH, and the Admin operations add IAM on top.
When a Native API Client Wins#
The three alternatives from the opening each have a case where they win; the questions below are how to find it.
| Question | Points at this pattern | Points away |
|---|---|---|
| Who else calls the backend? | Only the product’s own clients | Partners or a public API; the team services are a start, but they need a public contract, and the web app can still be RSC |
| Does the mobile app need offline writes? | No | Yes; a native client with a sync layer |
| How much of the mobile UI must be native? | The frame and a few screens; the shell can host native screens next to WebViews | Most screens; a native app with an API |
| Where does identity live? | One IdP with WebAuthn (Cognito, Auth0, Entra); the ceremony runs server-side | Social or SMS OTP flows use the same mechanism; this rarely points away |
| What is the store-review posture? | Native navigation, a native capability or two, and account deletion if the app creates accounts | A bare WebView may fall under Apple’s guideline 4.2 on minimum functionality; this shell passed once, which is one data point |
Gained: one auth implementation, one place per team where identity turns into a data query, and one table per service that only that service’s role can touch. The token sits on the device only as an HttpOnly cookie in the WebView’s store: page JavaScript cannot read it, and the shell’s native code never touches it. One passkey ceremony serves the browser and the iOS shell; on Android the build reached the system passkey sheet, not a finished sign-in. One deploy updates web and mobile content without an app release. Paid: every mobile screen is a server render over the network, every data read adds an app-to-service hop, and per-client chrome costs the prerender. The service domains stay on the internet, but they accept only requests signed by the owning app’s role. The shell still needs platform attestation files and a patched WebView on Android, and session lifetime is whatever the cookie says. Beyond the frame, the shell’s native code is the Face ID lock and the camera hand-off; it has no push registration, deep links into tabs, offline reads, or native screens next to the WebView tabs. A product build adds native code for each; the first three do not move the boundary, because none needs an API the page servers do not already front.
Where the Default Holds#
The default holds when the backend has no consumer besides the product’s own clients, the mobile UI is a frame around server-rendered screens, and identity lives in one provider with WebAuthn. It gives way to a native API client when partners consume the backend, the app needs offline writes, or most screens must be native. Inside the default, the first version drew the boundary at the page server and gave up team-owned services to keep it there. The current build keeps the client-facing boundary and moves the data boundary one hop back, into a service per team. It pays for that with a signed, synchronous call per read. The other places the boundary moves are platform attestation on both sides, the CSRF origin check behind a TLS-terminating proxy, and the prerender lost to per-client chrome. On a new build, check the two well-known files at the public domain first; every other mobile step depends on them.
References#
- Lambda Web Functions runtimes (opens in new tab) - How a web function’s process listens on
AWS_LAMBDA_HTTP_ENDPOINT - Lambda Web Function endpoint access control (opens in new tab) -
IamAuth,lambda:InvokeWebFunctionEndpoint, and theAuthorizationheader Lambda removes after validating a signature - Configuring networking for Lambda Web Functions (opens in new tab) - Endpoint domains stay on the public internet;
IamAuthcontrols who can invoke, not network reachability - Lambda event-driven architectures (opens in new tab) - The “Anti-patterns in Lambda-based event-driven applications” section, which names functions calling functions and the durable-functions exception
- AWS Prescriptive Guidance, synchronous communication between microservices (opens in new tab) - Synchronous calls as the widely accepted standard, with predictable flow control and strong consistency among the benefits
- Cognito authentication flows and the USER_AUTH choice-based flow (opens in new tab) -
USER_AUTHwithPREFERRED_CHALLENGEand how passkeys fit as a first factor - Cognito API reference: AdminInitiateAuth (opens in new tab) -
USER_AUTH,PREFERRED_CHALLENGE,SECRET_HASH, and theCREDENTIAL_REQUEST_OPTIONSchallenge parameter - Cognito API reference: AdminRespondToAuthChallenge (opens in new tab) - The
WEB_AUTHNchallenge, itsCREDENTIALresponse, andSECRET_HASH - Cognito API reference: InitiateAuth (opens in new tab) - The public, unauthenticated counterpart an early cut used
- Cognito API reference: DeleteUser (opens in new tab) - Self-service deletion with the user’s access token, behind the account page’s delete button
- Cognito SDK authorization models (opens in new tab) - Public versus server-side operations, and why the Admin pair needs IAM credentials
- aws-jwt-verify (opens in new tab) - Verifying the Cognito access token in the apps and again in each service
- Server-Side Rendering Micro-Frontends in AWS (opens in new tab) - The AWS reference architecture for server-side composition, the sibling pattern of the vertical split here
- React Router React Server Components (opens in new tab) - RSC Framework Mode, resource routes, and
shouldRevalidate - Supporting associated domains (opens in new tab) - The
webcredentialsservice and the AASA file - Associated Domains Entitlement (opens in new tab) - When
?mode=developerapplies: developer-mode devices, development-profile-signed apps, user opt-in - Supporting passkeys (opens in new tab) - How Apple’s platform authenticator binds a passkey to a relying party, and the WKWebView check for passkey support in iOS 16.4 and later
- App Review Guidelines (opens in new tab) - 2.1 on app completeness and demo accounts, 4.2 on minimum functionality, and 5.1.1(v) on account deletion
- Offering account deletion in your app (opens in new tab) - Apple’s guidance on what in-app account deletion must cover
- RSC Shell on the App Store (opens in new tab) - The published iOS shell, its category and its privacy label
- WebSettingsCompat reference (opens in new tab) -
setWebAuthenticationSupportandWEB_AUTHENTICATION_SUPPORT_FOR_APP - Credential Manager, passkeys in WebView (opens in new tab) - The WebView passkey guide and its Digital Asset Links requirement
- Credential Manager prerequisites (opens in new tab) - The
get_login_credsandhandle_all_urlsrelations inassetlinks.json - react-native-webview reference (opens in new tab) -
applicationNameForUserAgent,sharedCookiesEnabled,allowsBackForwardNavigationGestures, andonShouldStartLoadWithRequest - react-native-webview v14.0.1 iOS implementation (opens in new tab) -
sharedCookiesEnabledwrites WebView cookies intoNSHTTPCookieStoragewithout deleting them and seeds new WebViews from it - react-native-safe-area-context (opens in new tab) -
useSafeAreaInsets, which keeps the WebView below the status bar on both platforms - SimpleWebAuthn browser package (opens in new tab) -
startRegistrationandstartAuthenticationwithoptionsJSON - CaSE podcast, Micro Frontends with Gustaf Nilsson Kotte (opens in new tab) - Team-owned pages and fragments in IKEA’s M2 project, composed with Edge Side Includes
- Zalando, Micro Frontends: from Fragments to Renderers (Part 1) (opens in new tab) - Project Mosaic’s team-owned fragments and the move to Interface Framework
- Zalando, Micro Frontends: Deep Dive into Rendering Engine (Part 2) (opens in new tab) - The Rendering Engine that stitches components and streams the HTML
- Spotify, Building Spotify’s New Web Player (opens in new tab) - Per-team iframe views in the desktop client and the move to one React codebase
- Werner Vogels, Amazon’s Dynamo (opens in new tab) - A page request to the e-commerce site fanning out to over 150 services behind one rendering engine
- Hotwire Native (opens in new tab) - The native-frame, web-content shape the shell follows
- ayhansipahi/rsc-mfe-demo (opens in new tab) - The shells, apps, services, CDK app, pipeline, and the WebView patch
Related posts
A React Router RSC app on Lambda Web Functions behind CloudFront: the entry shim, NODE_ENV, streaming, request-scoped state, partial rendering, and the origin hop.
lambda · serverless · react +3
Before building an internal service layer, decide whether you need one: what it costs per call, the volume where VPC Lattice wins, and when direct invoke still beats it.
aws · aws-cdk · lambda +4
A private REST API structurally cannot carry gRPC, and every AWS surface that speaks gRPC excludes Lambda targets. What to keep from gRPC, and what to drop.
aws · aws-cdk · lambda +4
The private REST API, the resource policy that switches it on, per-route AWS_IAM grants, the two CDK stacks, and signing the call from a Node 22 Lambda.
aws · aws-cdk · lambda +4
SigV4 proves which service is calling and nothing about which user it is for. How to propagate a verified subject, and what the transport actually encrypts.
aws · aws-cdk · lambda +4