[$250] Company Card - RHP "Export" page shown twice after back from "Export company card expenses as"

[jponikarchuk]

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!

---

Version Number: v9.3.70-1
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: https://test-management.browserstack.com/projects/2219752/test-runs/TR-28065/folder/13176706/41236845/1407058817
Email or phone of affected tester (no customers): applausetester+ccardfeed@applause.expensifail.com
Issue reported by: Applause Internal Team
Bug source: Regression TC Execution
Device used: Windows 11 / Chrome, iPhone 13 / iOS 26.5, Samsung Galaxy A52 / Android 14
App Component: Workspace Settings

Action Performed:

Preconditions:

• Logged in to applausetester+ccardfeed@applause.expensifail.com account
• Open workspace setting on Company Cards tests - DO NOT DELETE!
• Connect to QBO in accounting (disconnect it first if it already connected before then reconnect it)

Steps:

1. Navigate to Company Cards tab in workspace setting
2. Click on any card that assigned to that account
3. Click QuickBooks Online credit card export row
4. Tap a different account
5. Click QuickBooks Online credit card export row again
6. Tap default card
7. Click QuickBooks Online credit card export row again
8. Click the hyperlinked export option in the subheader of the list
9. Click Export company card expenses as row
10. Click Export as
11. Click debit card or credit card
12. Click back button (<) twice

Expected Result:

User land back on the card-level export page titled "QuickBooks Online debit card export" or "QuickBooks Online credit card export" (depends on what was chose in step 11)

Actual Result:

User lands on RHP page titled "Export"

Workaround:

Unknown

Platforms:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

Video.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022054179527311003556
• Upwork Job ID: 2054179527311003556
• Last Price Increase: 2026-05-26

[MelvinBot]

Proposal

What is the root cause of that problem?

DynamicQuickbooksExportConfigurationPage.tsx:51-53 hasn't been migrated to use useDynamicBackPath. It calls goBackFromExportConnection(shouldShowVendorMenuItems, backTo) without a dynamicBackPath (3rd argument). Since backTo is undefined when entering from the company card flow, goBackFromExportConnection falls through to Navigation.goBack(undefined) — a raw stack pop that doesn't reliably navigate back to the company card export page.

The QBD equivalent (DynamicQuickbooksDesktopExportPage.tsx:26,38-40) was already migrated correctly — it uses useDynamicBackPath and passes the result as the 3rd argument to goBackFromExportConnection. The TODO on line 14 of goBackFromExportConnection confirms this migration is incomplete.

What changes do you think we should make in order to solve the problem?

In DynamicQuickbooksExportConfigurationPage.tsx, add useDynamicBackPath (matching the QBD pattern):

1. Import useDynamicBackPath and DYNAMIC_ROUTES
2. Add const dynamicBackPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path);
3. Update goBack to pass dynamicBackPath as the 3rd argument: goBackFromExportConnection(shouldShowVendorMenuItems, undefined, dynamicBackPath)

What alternative solutions did you explore? (Optional)

The same bug pattern exists in NetSuiteExportConfigurationPage.tsx:57-61 — it uses useDynamicBackPath but passes the result as the 2nd argument (backTo) instead of the 3rd (dynamicBackPath), so Navigation.goBack(dynamicBackPath) still receives undefined. This should be fixed in the same PR.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, @MelvinBot <your feedback> to refine this analysis, or explain why you are rejecting Melvin's proposal.

[MobileMage]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a user navigates from the card-level "Export" page (WorkspaceCompanyCardAccountSelectCardPage) to the workspace-level QBO Export page via the hyperlinked subheader, and then navigates back twice, they land on an intermediate "Export" RHP page instead of the card-level export page they started from. The "Export" RHP is effectively shown twice in the stack.

What is the root cause of that problem?

The card-level export page (WorkspaceCompanyCardAccountSelectCardPage) shows a hyperlinked subheader whose URL is built by getExportMenuItem in utils.tsx. For the QBO case, exportPageLink is built as:

createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath)

where basePath is ROUTES.POLICY_ACCOUNTING.getRoute(policyID) (e.g. workspaces/<policyID>/accounting). This produces the URL workspaces/<policyID>/accounting/quickbooks-online/export, which is the workspace-level QBO export route. The RenderHTML hyperlink in WorkspaceCompanyCardAccountSelectCardPage (line 96) renders this URL and when the user taps it, the app performs a standard Navigation.navigate() call to that URL — pushing the workspace-level QBO Export screen onto the stack on top of the card-level Export screen (SCREENS.WORKSPACE.COMPANY_CARD_EXPORT). So the navigation stack is: ... → COMPANY_CARD_EXPORT → QBO_EXPORT_WORKSPACE_LEVEL. Pressing back once returns to COMPANY_CARD_EXPORT, which is the "Export" page (step 9 in reproduction), and pressing back again goes one more level up.

App/src/pages/workspace/companyCards/utils.tsx

Line 109 in 194f7f6

exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),

The DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT already declares SCREENS.WORKSPACE.COMPANY_CARD_EXPORT as a valid entryScreen (alongside SCREENS.WORKSPACE.ACCOUNTING.ROOT), which confirms that the export route is intentionally reachable from the card export screen. The problem is that navigating to it via the hyperlink pushes a new stack entry rather than replacing the current one or using a back-aware navigation that won't double the stack.

App/src/ROUTES.ts

Lines 206 to 209 in 194f7f6

	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT: {
	path: 'quickbooks-online/export',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.ROOT, SCREENS.WORKSPACE.COMPANY_CARD_EXPORT],
	},

What changes do you think we should make in order to solve the problem?

The fix should be applied in getExportMenuItem inside src/pages/workspace/companyCards/utils.tsx. For integrations that support it (QBO, Xero, NetSuite, QBD, Sage Intacct), the exportPageLink should encode the current card-export screen route as a backTo parameter, so that when the user is on the workspace-level export page and presses back, navigation returns directly to the card-level export page instead of inserting a phantom intermediate stop.

Concretely, for the QBO case on line 109, the exportPageLink should be built with a backTo query parameter pointing to ROUTES.WORKSPACE_COMPANY_CARD_EXPORT.getRoute(policyID, cardID, feed) (or whatever the active card-export route is). The workspace-level export page (DynamicQuickbooksExportConfigurationPage) already accepts and uses a backTo param via its goBack callback, so this wires up cleanly without further changes to that page.

Alternatively — and more robustly — the exportPageLink URL could be changed to use Navigation.navigate with NavigationActions.replace semantics when the hyperlink is tapped, so the card-level export screen is replaced in the stack rather than stacked beneath the workspace-level one. This would require the RenderHTML / hyperlink handler to be swapped for an explicit onPress prop on a pressable element in WorkspaceCompanyCardAccountSelectCardPage, replacing the current RenderHTML subheader with a MenuItemWithTopDescription or similar component that calls Navigation.navigate(exportPageLink) using a replace action. This avoids the extra stack entry entirely and doesn't depend on backTo being threaded through every caller.

What alternative solutions did you explore? (Optional)

N/A

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @eh2077 (External)

[dilshodmackbook-sketch]

Proposal

What is the root cause of that problem?

I reproduced the navigation chain in code and the bug is on the App side: the "export" hyperlink in the subheader of the card-level export page (WorkspaceCompanyCardAccountSelectCardPage) loses the backTo context, so the dynamic back chain underneath the QBO Export page has no way to return to the card-level page — it can only walk back to the next URL segment up.

1. The hyperlink target is built without a backTo in utils.tsx:

App/src/pages/workspace/companyCards/utils.tsx

Lines 104 to 116 in cfeaadd

	return {
	description,
	title: isDefaultTitle ? defaultCard : selectedAccount?.name,
	exportType,
	shouldShowMenuItem,
	exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),
	data: resultData.map((card) => ({
	value: card.id,
	text: card.name,
	keyForList: card.name,
	isSelected: isDefaultTitle ? card.name === defaultCard : card.id === selectedAccount?.id,
	})),
	};

return {
    description,
    title: isDefaultTitle ? defaultCard : selectedAccount?.name,
    exportType,
    shouldShowMenuItem,
    exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),
    ...
};

exportPageLink is the URL embedded in the subheader's hyperlinked text (rendered by RenderHTML in WorkspaceCompanyCardAccountSelectCardPage). It points at quickbooks-online/export with no backTo query param.

2. The link click falls through to the generic openLink, which navigates without preserving any context:

App/src/libs/actions/Link.ts

Lines 172 to 212 in cfeaadd

	function openLink(href: string, environmentURL: string, isAttachment = false) {
	const hasSameOrigin = Url.hasSameExpensifyOrigin(href, environmentURL);
	const hasExpensifyOrigin = Url.hasSameExpensifyOrigin(href, CONFIG.EXPENSIFY.EXPENSIFY_URL) || Url.hasSameExpensifyOrigin(href, CONFIG.EXPENSIFY.STAGING_API_ROOT);
	const internalNewExpensifyPath = getInternalNewExpensifyPath(href);
	const internalExpensifyPath = getInternalExpensifyPath(href);
	const isNarrowLayout = getIsNarrowLayout();
	const currentState = navigationRef.getRootState();
	const isRHPOpen = currentState?.routes?.at(-1)?.name === NAVIGATORS.RIGHT_MODAL_NAVIGATOR;
	let shouldCloseRHP = false;
	if (!isNarrowLayout && isRHPOpen) {
	shouldCloseRHP = !willRouteNavigateToRHP(internalNewExpensifyPath as Route);
	}
	// There can be messages from Concierge with links to specific NewDot reports. Those URLs look like this:
	// https://www.expensify.com.dev/newdotreport?reportID=3429600449838908 and they have a target="_blank" attribute. This is so that when a user is on OldDot,
	// clicking on the link will open the chat in NewDot. However, when a user is in NewDot and clicks on the concierge link, the link needs to be handled differently.
	// Normally, the link would be sent to Link.openOldDotLink() and opened in a new tab, and that's jarring to the user. Since the intention is to link to a specific NewDot chat,
	// the reportID is extracted from the URL and then opened as an internal link, taking the user straight to the chat in the same tab.
	if (hasExpensifyOrigin && href.indexOf('newdotreport?reportID=') > -1) {
	const reportID = href.split('newdotreport?reportID=').pop();
	const reportRoute = ROUTES.REPORT_WITH_ID.getRoute(reportID);
	if (shouldCloseRHP) {
	Navigation.closeRHPFlow();
	}
	Navigation.navigate(reportRoute);
	return;
	}
	// If we are handling a New Expensify link then we will assume this should be opened by the app internally. This ensures that the links are opened internally via react-navigation
	// instead of in a new tab or with a page refresh (which is the default behavior of an anchor tag)
	if (internalNewExpensifyPath && hasSameOrigin) {
	if (isAnonymousUser() && !canAnonymousUserAccessRoute(internalNewExpensifyPath)) {
	signOutAndRedirectToSignIn();
	return;
	}
	if (shouldCloseRHP) {
	Navigation.closeRHPFlow();
	}
	Navigation.navigate(internalNewExpensifyPath as Route);
	return;

if (internalNewExpensifyPath && hasSameOrigin) {
    ...
    Navigation.navigate(internalNewExpensifyPath as Route);
    return;
}

RenderHTML in the card-level page has no onLinkPress override, so internal anchors hit this default path. The destination URL has no backTo, so the QBO Export RHP is pushed as a fresh entry.

3. The dynamic-back-path chain below QBO Export is URL-derived, not backTo-aware. Once the user drills QBO Export → Export company card expenses as → Export as → debit/credit, every screen computes its back path by stripping the last dynamic segment off the current URL — for example DynamicQuickbooksCompanyCardExpenseAccountSelectCardPage uses:

App/src/pages/workspace/accounting/qbo/export/DynamicQuickbooksCompanyCardExpenseAccountSelectCardPage.tsx

Lines 33 to 39 in cfeaadd

	const backPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_CARD_SELECT.path);
	const data: MenuItem[] = useMemo(() => {
	const options: MenuItem[] = [
	{
	text: translate(`workspace.qbo.accounts.credit_card`),
	value: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.CREDIT_CARD,

const backPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_CARD_SELECT.path);
...
const goBack = useCallback(() => {
    Navigation.goBack(backPath);
}, [backPath]);

Routes are defined as nested URL segments — card-select lives under company-card-expense-account, which lives under quickbooks-online/export:

App/src/ROUTES.ts

Lines 206 to 221 in cfeaadd

	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT: {
	path: 'quickbooks-online/export',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.ROOT, SCREENS.WORKSPACE.COMPANY_CARD_EXPORT],
	},
	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT: {
	path: 'company-card-expense-account',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_EXPORT],
	},
	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT_SELECT: {
	path: 'company-card-expense-account-select',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_EXPORT, SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT],
	},
	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_CARD_SELECT: {
	path: 'card-select',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT],
	},

POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT: {
    path: 'quickbooks-online/export',
    entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.ROOT, SCREENS.WORKSPACE.COMPANY_CARD_EXPORT],
},
POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT: {
    path: 'company-card-expense-account',
    entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_EXPORT],
},
POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_CARD_SELECT: {
    path: 'card-select',
    entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT],
},

So the back trail after step 11 (card-select) is:

• press 1: strip card-select → quickbooks-online/export/company-card-expense-account
• press 2: strip company-card-expense-account → quickbooks-online/export ← this is the generic "Export" RHP the user lands on, instead of the card-level page

The card-level page (WORKSPACE_COMPANY_CARD_EXPORT) lives at a completely different URL (workspaces/:policyID/company-cards/:feed/:cardID/edit/export) — it's not a parent segment of quickbooks-online/export, so URL-based back can never reach it. The only way back is via an explicit backTo, and that backTo is never set because step 8's hyperlink dropped it on the floor.

Note WORKSPACE_COMPANY_CARD_EXPORT already accepts a backTo and is in the entryScreens list for POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT:

App/src/ROUTES.ts

Lines 2792 to 2796 in cfeaadd

	WORKSPACE_COMPANY_CARD_EXPORT: {
	route: 'workspaces/:policyID/company-cards/:feed/:cardID/edit/export',
	getRoute: (policyID: string, cardID: string, feed: CompanyCardFeedWithDomainID, backTo?: string) =>
	// eslint-disable-next-line no-restricted-syntax -- Legacy route generation
	getUrlWithBackToParam(`workspaces/${policyID}/company-cards/${feed}/${cardID}/edit/export`, backTo, false),

— so the back-target is already a first-class entry screen; the only missing piece is wiring the hyperlink to declare it.

What changes do you think we should make in order to solve the problem?

Build the subheader hyperlink with a backTo pointing to the card-level export page, so that when the back-chain unwinds out of the QBO Export RHP it returns to where the user opened it from instead of stranding them on the bare "Export" page.

In src/pages/workspace/companyCards/utils.tsx (the QBO branch of getExportMenuItem, around L104-L116), thread the existing policyID / cardID / feed of the card-level page into the link via getUrlWithBackToParam:

-    exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),
+    exportPageLink: getUrlWithBackToParam(
+        createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),
+        ROUTES.WORKSPACE_COMPANY_CARD_EXPORT.getRoute(policyID, cardID, feed),
+        false,
+    ),

The same pattern applies to the Xero / NetSuite / Sage Intacct branches of getExportMenuItem in the same file — each one currently builds exportPageLink with a bare createDynamicRoute and would strand the user on the equivalent generic "Export" RHP for that connection. Mirror the wrap for each branch (using each connection's own DYNAMIC_ROUTES.*_EXPORT.path).

With backTo set, the back chain becomes:

• press 1: card-select → strip → company-card-expense-account
• press 2: company-card-expense-account → strip → quickbooks-online/export?backTo=<card-level>; goBack on the QBO Export entry screen honors backTo and lands on the card-level page

Two back presses, card-level page, matches Expected Result.

What alternative solutions did you explore? (Optional)

• Add an onLinkPress to RenderHTML in WorkspaceCompanyCardAccountSelectCardPage and intercept the navigation there. Rejected — it pushes the same fix into every consumer of the subheader RenderHTML (QBO, Xero, NetSuite, Intacct), whereas building the URL correctly at the source (getExportMenuItem) fixes all branches in one place.
• Modify openLink in Link.ts to auto-inject the current route as backTo for all internal links. Rejected — internal hyperlinks elsewhere (chat, settings, etc.) are deliberately context-free drill-ups; forcing a global backTo would change unrelated flows and risk creating back-loop cycles where a back-target navigates back to itself.
• Make useDynamicBackPath walk up multiple segments when no matching entry screen for the current entry context is found. Rejected — fragile, hard to reason about, and would still need someone to record the original entry context somewhere. backTo is the existing first-class mechanism for exactly this; use it.

[KJ21-ENG]

🚨 Edited by proposal-police: This proposal was edited at 2026-05-12 12:54:08 UTC.

Replaces my earlier proposal. The root cause and fix are still the same two-piece QBO dynamic-route fix, but ProposalPolice cited MobileMage's earlier URL-only proposal. This update explicitly shows why URL/backTo-only and page-only fixes are incomplete for the debit/credit path in the media.

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a user opens a company card's QBO export account selector, follows the "export option" link, changes "Export company card expenses as", and presses back twice, they should return to the card-level export account page.

Instead, the route history lands on another RHP titled "Export", so the user has to back out through an extra QBO export page. The attached video confirms this after selecting debit card: the child selector unwinds, but the remaining page is the generic QBO Export RHP instead of the card-level "QuickBooks Online debit/credit card export" page.

What is the root cause of that problem?

The company-card export selector already captures its own stable route and passes it into getExportMenuItem() so the export option link can be built from the card-level page.

App/src/pages/workspace/companyCards/WorkspaceCompanyCardAccountSelectCardPage.tsx

Lines 43 to 46 in 81390e7

	// We need to have an unchanged active route for getExportMenuItem so the export page link is not updated incorrectly when user is in other pages
	// See https://github.com/Expensify/App/issues/72352 for more details.
	const activeRoute = Navigation.getActiveRoute();
	const exportMenuItem = getExportMenuItem(connectedIntegration, policyID, translate, policy, card, activeRoute);

But the QBO branch ignores that backTo/active-route argument and always builds exportPageLink from ROUTES.POLICY_ACCOUNTING.getRoute(policyID), even though the dynamic QBO export route is explicitly allowed to enter from SCREENS.WORKSPACE.COMPANY_CARD_EXPORT.

App/src/pages/workspace/companyCards/utils.tsx

Lines 20 to 29 in 81390e7

	function getExportMenuItem(
	connectionName: PolicyConnectionName | undefined,
	policyID: string,
	translate: LocaleContextProps['translate'],
	policy?: Policy,
	companyCard?: Card,
	backTo?: string | undefined,
	): ExportIntegration | undefined {
	const basePath = ROUTES.POLICY_ACCOUNTING.getRoute(policyID);
	const currentConnectionName = getCurrentConnectionName(policy);

App/src/pages/workspace/companyCards/utils.tsx

Lines 104 to 110 in 81390e7

	return {
	description,
	title: isDefaultTitle ? defaultCard : selectedAccount?.name,
	exportType,
	shouldShowMenuItem,
	exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),
	data: resultData.map((card) => ({

App/src/ROUTES.ts

Lines 206 to 208 in 81390e7

	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT: {
	path: 'quickbooks-online/export',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.ROOT, SCREENS.WORKSPACE.COMPANY_CARD_EXPORT],

That leaves the QBO Export page with no reliable way to compute the card-level export page as its parent in the current checkout. The QBO Export page then compounds the problem because its back handler only passes the optional backTo param to goBackFromExportConnection() and never passes a dynamic back path. In the debit/credit path from the video, shouldShowVendorMenuItems is false, so goBackFromExportConnection() falls through to Navigation.goBack(dynamicBackPath). Since QBO never supplies dynamicBackPath, that becomes a raw Navigation.goBack(undefined) instead of stripping quickbooks-online/export from the current dynamic URL.

App/src/pages/workspace/accounting/qbo/export/DynamicQuickbooksExportConfigurationPage.tsx

Lines 32 to 53 in 81390e7

	const route = useRoute<PlatformStackRouteProp<SettingsNavigatorParamList, typeof SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_EXPORT>>();
	const backTo = route?.params?.backTo;
	const policyID = policy?.id;
	const policyOwner = policy?.owner ?? '';
	const qboConfig = policy?.connections?.quickbooksOnline?.config;
	const errorFields = qboConfig?.errorFields;
	const {accountPayable} = policy?.connections?.quickbooksOnline?.data ?? {};
	const travelPayableAccount = accountPayable?.find((account) => account.id === qboConfig?.travelInvoicingPayableAccountID);
	const workspaceAccountID = useWorkspaceAccountID(policyID);
	const [cardSettings] = useOnyx(getTravelInvoicingCardSettingsKey(workspaceAccountID));
	const travelSettings = getCardSettings(cardSettings, CONST.TRAVEL.PROGRAM_TRAVEL_US);
	const isTravelInvoicingEnabled = isBetaEnabled(CONST.BETAS.TRAVEL_INVOICING) && getIsTravelInvoicingEnabled(travelSettings);
	const shouldShowVendorMenuItems = useMemo(
	() => qboConfig?.nonReimbursableExpensesExportDestination === CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.VENDOR_BILL,
	[qboConfig?.nonReimbursableExpensesExportDestination],
	);
	const goBack = useCallback(() => {
	return goBackFromExportConnection(shouldShowVendorMenuItems, backTo);
	}, [backTo, shouldShowVendorMenuItems]);

App/src/libs/Navigation/helpers/goBackFromExportConnection.ts

Lines 10 to 17 in 81390e7

	function goBackFromExportConnection(shouldGoBackToSpecificRoute: boolean, backTo?: string, dynamicBackPath?: Route) {
	const feature = CONST.UPGRADE_FEATURE_INTRO_MAPPING.companyCards;
	const effectivePath = dynamicBackPath ?? backTo;
	// TODO: Remove `backTo` fallback once all routes using this helper are migrated to dynamic back paths.
	if (!(shouldGoBackToSpecificRoute && effectivePath?.includes(feature.alias))) {
	return Navigation.goBack(dynamicBackPath);
	}

The child "Export company card expenses as" and "Export as" pages already use useDynamicBackPath() to remove their own suffixes, so after selecting debit/credit they correctly return one level at a time. The broken level is the QBO Export page itself.

App/src/pages/workspace/accounting/qbo/export/DynamicQuickbooksCompanyCardExpenseAccountPage.tsx

Lines 30 to 65 in 81390e7

	const backPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT.path);
	const {isAccordionExpanded, shouldAnimateAccordionSection} = useAccordionAnimation(!!qboConfig?.autoCreateVendor);
	const sections = [
	{
	title: qboConfig?.nonReimbursableExpensesExportDestination ? translate(`workspace.qbo.accounts.${qboConfig?.nonReimbursableExpensesExportDestination}`) : undefined,
	description: translate('workspace.accounting.exportAs'),
	onPress: () => Navigation.navigate(createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_CARD_SELECT.path)),
	hintText: qboConfig?.nonReimbursableExpensesExportDestination ? translate(`workspace.qbo.accounts.${qboConfig?.nonReimbursableExpensesExportDestination}Description`) : undefined,
	subscribedSettings: [CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_EXPENSE_EXPORT_DESTINATION],
	},
	{
	title: qboConfig?.nonReimbursableExpensesAccount?.name,
	description: getQBONonReimbursableExportAccountType(translate, qboConfig?.nonReimbursableExpensesExportDestination),
	onPress: () => {
	if (!policyID) {
	return;
	}
	Navigation.navigate(createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_ACCOUNT_SELECT.path));
	},
	subscribedSettings: [CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_EXPENSE_ACCOUNT],
	},
	];
	return (
	<ConnectionLayout
	policyID={policyID}
	displayName="DynamicQuickbooksCompanyCardExpenseAccountPage"
	headerTitle="workspace.accounting.exportCompanyCard"
	title="workspace.qbo.exportCompanyCardsDescription"
	accessVariants={[CONST.POLICY.ACCESS_VARIANTS.ADMIN]}
	featureName={CONST.POLICY.MORE_FEATURES.ARE_CONNECTIONS_ENABLED}
	contentContainerStyle={styles.pb2}
	titleStyle={styles.ph5}
	connectionName={CONST.POLICY.CONNECTIONS.NAME.QBO}
	onBackButtonPress={() => Navigation.goBack(backPath)}

App/src/pages/workspace/accounting/qbo/export/DynamicQuickbooksCompanyCardExpenseAccountSelectCardPage.tsx

Lines 33 to 89 in 81390e7

	const backPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_COMPANY_CARD_EXPENSE_CARD_SELECT.path);
	const data: MenuItem[] = useMemo(() => {
	const options: MenuItem[] = [
	{
	text: translate(`workspace.qbo.accounts.credit_card`),
	value: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.CREDIT_CARD,
	keyForList: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.CREDIT_CARD,
	isSelected: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.CREDIT_CARD === qboConfig?.nonReimbursableExpensesExportDestination,
	accounts: creditCards ?? [],
	defaultVendor: CONST.INTEGRATION_ENTITY_MAP_TYPES.NONE,
	},
	{
	text: translate(`workspace.qbo.accounts.debit_card`),
	value: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.DEBIT_CARD,
	keyForList: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.DEBIT_CARD,
	isSelected: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.DEBIT_CARD === qboConfig?.nonReimbursableExpensesExportDestination,
	accounts: bankAccounts ?? [],
	defaultVendor: CONST.INTEGRATION_ENTITY_MAP_TYPES.NONE,
	},
	];
	if (!isLocationEnabled) {
	options.push({
	text: translate(`workspace.qbo.accounts.bill`),
	value: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.VENDOR_BILL,
	keyForList: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.VENDOR_BILL,
	isSelected: CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.VENDOR_BILL === qboConfig?.nonReimbursableExpensesExportDestination,
	accounts: accountPayable ?? [],
	defaultVendor: vendors?.[0]?.id ?? CONST.INTEGRATION_ENTITY_MAP_TYPES.NONE,
	});
	}
	return options;
	}, [translate, qboConfig?.nonReimbursableExpensesExportDestination, isLocationEnabled, accountPayable, bankAccounts, creditCards, vendors]);
	const goBack = useCallback(() => {
	Navigation.goBack(backPath);
	}, [backPath]);
	const selectExportCompanyCard = useCallback(
	(row: MenuItem) => {
	if (row.value !== qboConfig?.nonReimbursableExpensesExportDestination) {
	updateManyPolicyConnectionConfigs(
	policyID,
	CONST.POLICY.CONNECTIONS.NAME.QBO,
	{
	[CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_EXPENSES_EXPORT_DESTINATION]: row.value,
	[CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_EXPENSES_ACCOUNT]: row.accounts.at(0),
	[CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_BILL_DEFAULT_VENDOR]: row.defaultVendor,
	},
	{
	[CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_EXPENSES_EXPORT_DESTINATION]: qboConfig?.nonReimbursableExpensesExportDestination,
	[CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_EXPENSES_ACCOUNT]: qboConfig?.nonReimbursableExpensesAccount,
	[CONST.QUICKBOOKS_CONFIG.NON_REIMBURSABLE_BILL_DEFAULT_VENDOR]: qboConfig?.nonReimbursableBillDefaultVendor,
	},
	);
	}
	goBack();

What changes do you think we should make in order to solve the problem?

In src/pages/workspace/companyCards/utils.tsx, update the QBO exportPageLink to use the card-level route argument when present:

createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, backTo ?? basePath)

This makes the hyperlink from WorkspaceCompanyCardAccountSelectCardPage open QBO Export as a child of WORKSPACE_COMPANY_CARD_EXPORT, which is already an allowed entry screen for that dynamic route.

In src/pages/workspace/accounting/qbo/export/DynamicQuickbooksExportConfigurationPage.tsx, import useDynamicBackPath, compute:

const dynamicBackPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path);

Then pass it into the existing helper:

goBackFromExportConnection(shouldShowVendorMenuItems, backTo, dynamicBackPath)

This mirrors the current QBD export-page migration pattern, where the export page strips the dynamic export suffix instead of falling back to raw history.

App/src/pages/workspace/accounting/qbd/export/DynamicQuickbooksDesktopExportPage.tsx

Lines 7 to 40 in 81390e7

	import useDynamicBackPath from '@hooks/useDynamicBackPath';
	import useLocalize from '@hooks/useLocalize';
	import useThemeStyles from '@hooks/useThemeStyles';
	import createDynamicRoute from '@libs/Navigation/helpers/dynamicRoutesUtils/createDynamicRoute';
	import {areSettingsInErrorFields, settingsPendingAction} from '@libs/PolicyUtils';
	import goBackFromExportConnection from '@navigation/helpers/goBackFromExportConnection';
	import Navigation from '@navigation/Navigation';
	import type {WithPolicyConnectionsProps} from '@pages/workspace/withPolicyConnections';
	import withPolicyConnections from '@pages/workspace/withPolicyConnections';
	import CONST from '@src/CONST';
	import ROUTES, {DYNAMIC_ROUTES} from '@src/ROUTES';
	function DynamicQuickbooksDesktopExportPage({policy}: WithPolicyConnectionsProps) {
	const {translate} = useLocalize();
	const styles = useThemeStyles();
	const policyID = policy?.id;
	const policyOwner = policy?.owner ?? '';
	const qbdConfig = policy?.connections?.quickbooksDesktop?.config;
	const errorFields = qbdConfig?.errorFields;
	const dynamicBackPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_DESKTOP_EXPORT.path);
	const shouldShowVendorMenuItems = useMemo(
	() => qbdConfig?.export?.nonReimbursable === CONST.QUICKBOOKS_DESKTOP_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.VENDOR_BILL,
	[qbdConfig?.export?.nonReimbursable],
	);
	const shouldGoBackToSpecificRoute = useMemo(
	() => qbdConfig?.export?.nonReimbursable === CONST.QUICKBOOKS_DESKTOP_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.CHECK || shouldShowVendorMenuItems,
	[qbdConfig?.export?.nonReimbursable, shouldShowVendorMenuItems],
	);
	const goBack = useCallback(() => {
	return goBackFromExportConnection(shouldGoBackToSpecificRoute, undefined, dynamicBackPath);
	}, [dynamicBackPath, shouldGoBackToSpecificRoute]);

Scope boundaries:

• Files touched: src/pages/workspace/companyCards/utils.tsx - QBO getExportMenuItem() branch (exportPageLink); src/pages/workspace/accounting/qbo/export/DynamicQuickbooksExportConfigurationPage.tsx - goBack setup for the QBO Export RHP.
• Platforms: all platforms using the shared workspace/company-card/QBO export routes.
• Code paths not touched: QBO account update actions, child QBO company-card expense/account selector pages, other accounting integrations unless their own issue proves the same route-base mismatch.
• API/backend changes: none.
• Tests: no targeted test file was found for DynamicQuickbooksCompanyCardExpenseAccountSelectCardPage / QBO company-card export route navigation in the current checkout.

What alternative solutions did you explore? (Optional)

MobileMage's earlier proposal, which ProposalPolice cited as the duplicate, fixes only the link/backTo side. That is incomplete for this issue's debit/credit path because goBackFromExportConnection(false, backTo) does not navigate to backTo; it returns Navigation.goBack(dynamicBackPath), and QBO currently passes no dynamicBackPath.

MelvinBot and aswin-s focus on adding useDynamicBackPath() only on DynamicQuickbooksExportConfigurationPage. That matches the broken page level shown in the media, but it is incomplete against the current checkout because the QBO company-card hyperlink is still built from the accounting root. Stripping quickbooks-online/export from an accounting-root URL returns Accounting, not the card-level export page.

wildan-m later converged on the same two-piece shape: fix the QBO hyperlink base and add the QBO Export dynamicBackPath. I agree with that fix shape; the important difference from the cited duplicate is that both pieces are required.

[yusufdeveloper2903]

Proposal

What is the root cause of that problem?

This is a regression introduced by PR #87418 ("BT - Migrate QBO EXPORT Routes - 1", merged 2026-04-16), which migrated QBO export routes to dynamic routes. The repro path enters the QBO Export RHP from the company-cards hyperlink, which the PR's QA matrix did not cover (only entry from Accounting → Export). Two changes from that migration combine to produce the bug:

1. The hyperlink in the card-level export subheader stopped propagating backTo.

The card-level export page (QuickBooks Online credit card export) renders an <a href> whose target is the URL stored in exportMenuItem.exportPageLink. Before the migration, that URL carried the company-cards route as backTo. After the migration it does not:

App/src/pages/workspace/companyCards/utils.tsx

Lines 102 to 116 in 9592e88

	const resultData = data.length > 0 ? [defaultMenuItem, ...data] : data;
	return {
	description,
	title: isDefaultTitle ? defaultCard : selectedAccount?.name,
	exportType,
	shouldShowMenuItem,
	exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),
	data: resultData.map((card) => ({
	value: card.id,
	text: card.name,
	keyForList: card.name,
	isSelected: isDefaultTitle ? card.name === defaultCard : card.id === selectedAccount?.id,
	})),
	};

createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath) produces workspaces/<policyID>/accounting/quickbooks-online/export with no ?backTo=…, even though the caller still passes activeRoute into getExportMenuItem:

App/src/pages/workspace/companyCards/WorkspaceCompanyCardAccountSelectCardPage.tsx

Lines 42 to 46 in 9592e88

	const connectedIntegration = getConnectedIntegration(policy) ?? CONST.POLICY.CONNECTIONS.NAME.QBO;
	// We need to have an unchanged active route for getExportMenuItem so the export page link is not updated incorrectly when user is in other pages
	// See https://github.com/Expensify/App/issues/72352 for more details.
	const activeRoute = Navigation.getActiveRoute();
	const exportMenuItem = getExportMenuItem(connectedIntegration, policyID, translate, policy, card, activeRoute);

The pre-migration line was ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.getRoute(policyID, backTo) — the backTo argument is exactly what's missing now.

2. goBackFromExportConnection discards backTo whenever shouldShowVendorMenuItems is false.

When the user picks debit card or credit card in step 11, nonReimbursableExpensesExportDestination is CREDIT_CARD/DEBIT_CARD, so shouldShowVendorMenuItems evaluates to false on the QBO Export page. The back handler then walks into the if branch and only forwards dynamicBackPath to Navigation.goBack — backTo is silently dropped:

App/src/libs/Navigation/helpers/goBackFromExportConnection.ts

Lines 10 to 20 in 9592e88

	function goBackFromExportConnection(shouldGoBackToSpecificRoute: boolean, backTo?: string, dynamicBackPath?: Route) {
	const feature = CONST.UPGRADE_FEATURE_INTRO_MAPPING.companyCards;
	const effectivePath = dynamicBackPath ?? backTo;
	// TODO: Remove `backTo` fallback once all routes using this helper are migrated to dynamic back paths.
	if (!(shouldGoBackToSpecificRoute && effectivePath?.includes(feature.alias))) {
	return Navigation.goBack(dynamicBackPath);
	}
	const companyCardDetailsPage = replaceCompanyCardsRoute(effectivePath);
	return Navigation.goBack(companyCardDetailsPage, {compareParams: false});
	}

App/src/pages/workspace/accounting/qbo/export/DynamicQuickbooksExportConfigurationPage.tsx

Lines 32 to 53 in 9592e88

	const route = useRoute<PlatformStackRouteProp<SettingsNavigatorParamList, typeof SCREENS.WORKSPACE.ACCOUNTING.DYNAMIC_QUICKBOOKS_ONLINE_EXPORT>>();
	const backTo = route?.params?.backTo;
	const policyID = policy?.id;
	const policyOwner = policy?.owner ?? '';
	const qboConfig = policy?.connections?.quickbooksOnline?.config;
	const errorFields = qboConfig?.errorFields;
	const {accountPayable} = policy?.connections?.quickbooksOnline?.data ?? {};
	const travelPayableAccount = accountPayable?.find((account) => account.id === qboConfig?.travelInvoicingPayableAccountID);
	const workspaceAccountID = useWorkspaceAccountID(policyID);
	const [cardSettings] = useOnyx(getTravelInvoicingCardSettingsKey(workspaceAccountID));
	const travelSettings = getCardSettings(cardSettings, CONST.TRAVEL.PROGRAM_TRAVEL_US);
	const isTravelInvoicingEnabled = isBetaEnabled(CONST.BETAS.TRAVEL_INVOICING) && getIsTravelInvoicingEnabled(travelSettings);
	const shouldShowVendorMenuItems = useMemo(
	() => qboConfig?.nonReimbursableExpensesExportDestination === CONST.QUICKBOOKS_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.VENDOR_BILL,
	[qboConfig?.nonReimbursableExpensesExportDestination],
	);
	const goBack = useCallback(() => {
	return goBackFromExportConnection(shouldShowVendorMenuItems, backTo);
	}, [backTo, shouldShowVendorMenuItems]);

Because the Export page itself is the entry point of the QBO Export modal stack (its entryScreens include ACCOUNTING.ROOT and COMPANY_CARD_EXPORT, see

App/src/ROUTES.ts

Lines 206 to 209 in 9592e88

	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT: {
	path: 'quickbooks-online/export',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.ROOT, SCREENS.WORKSPACE.COMPANY_CARD_EXPORT],
	},

), calling Navigation.goBack(undefined) from it cannot reach the card-level export page in the company-cards stack, so the user remains stuck on the RHP titled "Export".

What changes do you think we should make in order to solve the problem?

Restore the two pieces the migration dropped — propagate backTo on the hyperlink and honor it in the back handler.

1. In src/pages/workspace/companyCards/utils.tsx, build the QBO hyperlink with backTo again (this is the same shape used for Sage Intacct on line 299):

-                exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),
+                exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, backTo ?? basePath),

backTo here is the activeRoute passed in from WorkspaceCompanyCardAccountSelectCardPage, i.e. the card-level export route. Using it as the base path makes the resolved URL workspaces/<policyID>/company-cards/<feed>/<cardID>/edit/export/quickbooks-online/export, which keeps the company-cards stack alive under the QBO Export entry screen (SCREENS.WORKSPACE.COMPANY_CARD_EXPORT is already declared as a valid entry screen at

App/src/ROUTES.ts

Lines 206 to 209 in 9592e88

	POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT: {
	path: 'quickbooks-online/export',
	entryScreens: [SCREENS.WORKSPACE.ACCOUNTING.ROOT, SCREENS.WORKSPACE.COMPANY_CARD_EXPORT],
	},

).

2. In src/libs/Navigation/helpers/goBackFromExportConnection.ts, fall back to effectivePath (which already merges dynamicBackPath ?? backTo) so the non-vendor case stops dropping it:

     // TODO: Remove `backTo` fallback once all routes using this helper are migrated to dynamic back paths.
     if (!(shouldGoBackToSpecificRoute && effectivePath?.includes(feature.alias))) {
-        return Navigation.goBack(dynamicBackPath);
+        return Navigation.goBack((dynamicBackPath ?? backTo) as Route | undefined);
     }

That comment on line 14 already calls out this backTo fallback as the intended bridge until every caller adopts dynamic paths — the migration in #87418 just never wired the QBO Export entry from company-cards into the dynamic-path mechanism, so the fallback needs to actually be used.

With both changes, step 12's first back pops the "Export company card expenses as" page via the existing useDynamicBackPath chain, and the second back pops the "Export" page back to "QuickBooks Online credit card export" via the restored backTo.

What alternative solutions did you explore? (Optional)

• Only patch the hyperlink (change 1) without touching goBackFromExportConnection. This works for the vendor-bill flavor of the bug (where shouldShowVendorMenuItems is true and the existing branch handles backTo) but does nothing for the credit/debit-card path that this issue reports, since goBackFromExportConnection still routes through Navigation.goBack(dynamicBackPath = undefined).
• Only patch goBackFromExportConnection (change 2) without restoring backTo. The QBO Export page would still receive route.params.backTo === undefined, so the new fallback would have nothing to use. Both changes are needed.
• Hardcode the back target in DynamicQuickbooksExportConfigurationPage by reconstructing the card-level export URL from policyID/feed/cardID. The Export page has no access to those identifiers (it's part of the accounting stack), so this would require threading them through the URL anyway — i.e. the same backTo plumbing, but in a less-general form. The same regression also affects the Xero and NetSuite hyperlinks at lines 136 and 221 of utils.tsx; the backTo ?? basePath shape applied above generalizes cleanly to those if/when they are reported.

[kamronbek04]

🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.

[wildan-m]

Proposal

Please re-state the problem that we are trying to solve in this issue.

On a workspace connected to QuickBooks Online, opening the credit-card export setting for a specific Company Card and following the steps in the report (click the inline "export option" link in the card-export page's subheader, open "Export company card expenses as", change the export type, then press back twice) does not return the user to the card-level "QuickBooks Online credit/debit card export" page. Instead the RHP gets stuck on the workspace-level "Export" page — first back lands there correctly, but the second back is a no-op (or jumps to the workspace accounting page on web), so the user can never get back to the card-level export RHP they started from.

What is the root cause of that problem?

The QBO export config screens were migrated to dynamic routes in PR #88247. Two cleanups that this migration needed were applied to other connections but were missed for QBO:

1. The "Select a different export option" link rendered in the card-level export subheader is built in the QBO branch of getExportMenuItem here:

App/src/pages/workspace/companyCards/utils.tsx

Line 109 in 194f7f6

exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path, basePath),

The QBO branch uses basePath (the workspace accounting root URL) as the second argument to createDynamicRoute. That makes the link's URL workspaces/<policyID>/accounting/quickbooks-online/export — a path that has no relationship to the company-card RHP the user came from. Compare the Sage Intacct branch, which uses the incoming backTo (the active card-level export URL) as the base for the dynamic suffix:

App/src/pages/workspace/companyCards/utils.tsx

Line 299 in 194f7f6

exportPageLink: createDynamicRoute(DYNAMIC_ROUTES.POLICY_ACCOUNTING_SAGE_INTACCT_EXPORT.path, backTo ?? ROUTES.POLICY_ACCOUNTING.getRoute(policyID)),

Because of this, the URL of the workspace-level "Export" page no longer carries any pointer back to the card-level export RHP, so useDynamicBackPath on that page has nothing to strip down to.

2. DynamicQuickbooksExportConfigurationPage itself never registers a dynamic back path. Its goBack handler only forwards backTo (which is undefined since the link above doesn't pass one):

App/src/pages/workspace/accounting/qbo/export/DynamicQuickbooksExportConfigurationPage.tsx

Lines 51 to 53 in 194f7f6

	const goBack = useCallback(() => {
	return goBackFromExportConnection(shouldShowVendorMenuItems, backTo);
	}, [backTo, shouldShowVendorMenuItems]);

The follow-up PR #88842 ("fix: handle dynamic path in getExportForConnection") taught goBackFromExportConnection to accept a dynamicBackPath argument and updated the QuickBooks Desktop equivalent to compute one via useDynamicBackPath, but the QBO page was overlooked:

App/src/pages/workspace/accounting/qbd/export/DynamicQuickbooksDesktopExportPage.tsx

Lines 26 to 40 in 194f7f6

	const dynamicBackPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_DESKTOP_EXPORT.path);
	const shouldShowVendorMenuItems = useMemo(
	() => qbdConfig?.export?.nonReimbursable === CONST.QUICKBOOKS_DESKTOP_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.VENDOR_BILL,
	[qbdConfig?.export?.nonReimbursable],
	);
	const shouldGoBackToSpecificRoute = useMemo(
	() => qbdConfig?.export?.nonReimbursable === CONST.QUICKBOOKS_DESKTOP_NON_REIMBURSABLE_EXPORT_ACCOUNT_TYPE.CHECK || shouldShowVendorMenuItems,
	[qbdConfig?.export?.nonReimbursable, shouldShowVendorMenuItems],
	);
	const goBack = useCallback(() => {
	return goBackFromExportConnection(shouldGoBackToSpecificRoute, undefined, dynamicBackPath);
	}, [dynamicBackPath, shouldGoBackToSpecificRoute]);

With both backTo and dynamicBackPath undefined on the QBO Export page, goBackFromExportConnection falls through to a plain Navigation.goBack(undefined), which has no path information about the card-level export RHP that was the actual entry point, so it cannot pop back to it.

What changes do you think we should make in order to solve the problem?

Mirror the established patterns from Sage Intacct and QuickBooks Desktop:

a) In the QBO branch of getExportMenuItem in src/pages/workspace/companyCards/utils.tsx, build the "export option" link with the incoming backTo (the card-level export route) as the base for the dynamic suffix, falling back to the accounting root when called outside the card-export flow. This makes the link's URL workspaces/<policyID>/company-cards/<feed>/<cardID>/edit/export/quickbooks-online/export when the user enters from a card, exactly like Sage Intacct already does. The dynamic suffix quickbooks-online/export is then strippable to recover the card-level export RHP path.

b) In src/pages/workspace/accounting/qbo/export/DynamicQuickbooksExportConfigurationPage.tsx, import useDynamicBackPath, compute dynamicBackPath = useDynamicBackPath(DYNAMIC_ROUTES.POLICY_ACCOUNTING_QUICKBOOKS_ONLINE_EXPORT.path), and pass it as the third argument to goBackFromExportConnection inside the existing goBack callback (including it in the useCallback deps). After change (a) lands, stripping the quickbooks-online/export suffix from the current URL yields the card-level export RHP path, so the goBack target is correct. When the user reaches this page through the normal Workspace > Accounting flow, stripping yields workspaces/<policyID>/accounting (the workspace accounting page) which is the correct back destination for that entry path.

With both pieces in place, pressing back from the workspace-level "Export" RHP returns the user to the card-level "QuickBooks Online credit/debit card export" page as the issue expects, regardless of which export type (credit card / debit card / vendor bill) was just selected. The existing shouldShowVendorMenuItems second-branch logic in goBackFromExportConnection continues to work because dynamicBackPath now contains the company-cards alias when entering from a card, allowing the special redirect-to-card-details flow to fire when the user changes the export type to one that disables card-level export.

Compare branch: https://github.com/Expensify/App/compare/main...wildan-m:App:wildan/90335-qbo-card-export-back-nav?expand=1

What alternative solutions did you explore? (Optional)

Restoring the pre-migration approach of passing backTo as a query parameter (?backTo=...) on the workspace-level Export URL and routing on it in the page's goBack handler would also fix the user-visible symptom, but it diverges from the dynamic-route pattern that every other connection (QBD, Sage Intacct) already follows after the April migration, and goBackFromExportConnection's first branch currently only consumes dynamicBackPath for the Navigation.goBack target — making backTo alone insufficient without further helper changes. Aligning QBO with the existing Sage Intacct + QBD shape is the smaller, less-risky change.

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022054179527311003556