[$250] Infinite UpdateAutomaticTimezone loop when two devices are in different timezones

[mountiny]

Problem

When two devices with auto-timezone enabled are logged into the same account (or one is copiloting) and are in different timezones, an infinite loop of UpdateAutomaticTimezone API calls occurs, eventually bricking the request queue.

Root cause

The useAutoUpdateTimezone hook in src/hooks/useAutoUpdateTimezone.ts has a useEffect that depends on timezone?.selected. When Device A updates the timezone to its local value, Onyx pushes that change to Device B. Device B sees a mismatch between timezone.selected (now Device A's timezone) and its own local timezone, so it fires UpdateAutomaticTimezone with its timezone. This pushes back to Device A, and the cycle repeats infinitely.

Device A (TZ: America/New_York) → UpdateAutomaticTimezone(America/New_York)
  → Onyx push to Device B
Device B (TZ: Asia/Kolkata) → UpdateAutomaticTimezone(Asia/Kolkata)
  → Onyx push to Device A
... infinite loop

Impact

• The API request queue gets flooded with UpdateAutomaticTimezone commands
• The app becomes unresponsive / bricked on both devices
• Staging environments can accumulate thousands of queued commands

Proposed solution

Two changes to src/hooks/useAutoUpdateTimezone.ts:

1. Skip auto-timezone for copilot/delegate sessions — A copilot should never change the primary user's timezone. Check account?.delegatedAccess?.delegate (using isActingAsDelegateSelector from src/selectors/Account.ts) and bail out early.

2. Throttle timezone updates to once per hour — For the same-user-on-multiple-devices case, add a module-level timestamp tracker. Only allow updateAutomaticTimezone to fire if at least 1 hour has elapsed since the last update on this device. This breaks the loop because after Device A updates, Device B's update attempt will be throttled, and vice versa.

Reproduction steps

1. Log into the same account on two devices (or copilot into an account from a second device)
2. Ensure both devices have "Set timezone automatically" enabled
3. Set the two devices to different timezones
4. Open the App on both devices
5. Observe in the network tab that UpdateAutomaticTimezone calls fire continuously in an infinite loop

Expected: Timezone updates should not loop between devices
Actual: Infinite loop of UpdateAutomaticTimezone API calls floods the request queue

Related code

• src/hooks/useAutoUpdateTimezone.ts — the hook that triggers the update
• src/libs/actions/PersonalDetails.ts — updateAutomaticTimezone() function
• src/libs/Navigation/AppNavigator/AuthScreens.tsx — where the hook is called
• src/selectors/Account.ts — isActingAsDelegateSelector for copilot detection

Issue Owner

Current Issue Owner: @shubham1206agra

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022027508067836219274
• Upwork Job ID: 2027508067836219274
• Last Price Increase: 2026-02-27

[melvin-bot]

Triggered auto assignment to @dylanexpensify (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

[MelvinBot]

Proposal

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

When two devices logged into the same account (or one copiloting the other) have auto-timezone enabled and are in different timezones, the useAutoUpdateTimezone hook creates an infinite ping-pong of UpdateAutomaticTimezone API calls. Device A updates the timezone to its local value, Onyx pushes that to Device B via Pusher, Device B sees a mismatch and updates it back, and so on forever — flooding the request queue and bricking the app.

What is the root cause of that problem?

The useEffect in src/hooks/useAutoUpdateTimezone.ts:9-23 depends on timezone?.selected. When Device A calls updateAutomaticTimezone, the optimistic Onyx merge in src/libs/actions/PersonalDetails.ts:269-280 updates PERSONAL_DETAILS_LIST, and the server pushes this to Device B via Pusher (src/libs/actions/User.ts:928-955). Device B's useEffect re-fires because its timezone?.selected dependency changed, it detects a mismatch with its own local timezone, and fires updateAutomaticTimezone back. There is zero throttling, deduplication, or conflict resolution on this code path — API.write() is called with no conflictResolver and no debounce.

A secondary issue: the hook runs unconditionally in AuthScreens.tsx:209, including during copilot/delegate sessions. When a copilot connects, session.accountID becomes the delegator's, so useCurrentUserPersonalDetails returns the delegator's timezone — and the hook overwrites it with the copilot's device timezone. No delegate guard exists despite isActingAsDelegateSelector being available at src/selectors/Account.ts:4.

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

Two changes in src/hooks/useAutoUpdateTimezone.ts:

1. Skip auto-timezone for delegate sessions — Use isActingAsDelegateSelector (already exported from src/selectors/Account.ts) via useOnyx(ONYXKEYS.ACCOUNT, {selector: isActingAsDelegateSelector}). If acting as delegate, bail out early from the useEffect before calling updateAutomaticTimezone. A copilot should never modify the primary user's timezone.

2. Throttle updates to prevent the multi-device loop — Add a module-level variable (e.g., let lastUpdateTimestamp = 0) and check within the useEffect whether sufficient time has elapsed (e.g., 1 hour) since the last updateAutomaticTimezone call on this device. If not enough time has passed, skip the update. This breaks the infinite loop because after Device A updates, Device B's attempt is throttled, and the ping-pong stops. One hour is reasonable since timezone changes are infrequent (travel, DST transitions).

What alternative solutions did you explore? (Optional)

• Using API.writeWithNoDuplicatesConflictAction instead of plain API.write — This would deduplicate concurrent calls but wouldn't prevent the cross-device loop since each device sends a different selected value, so they aren't true duplicates.
• Removing timezone?.selected from the useEffect dependency array — This would prevent the loop but would also prevent the hook from reacting to legitimate timezone changes (e.g., user travels to a new timezone while the app is already open).
• Server-side deduplication — While the server could reject rapid successive timezone updates, the client-side fix is simpler and prevents unnecessary network traffic entirely.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, or @MelvinBot <your feedback> to refine this analysis.

[melvin-bot]

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

[melvin-bot]

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

[abbasifaizan70]

Proposal

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

When the same account is active on two devices in different local timezones (or one session is via copilot/delegate), the app continuously sends UpdateAutomaticTimezone from both devices.

Expected result: timezone auto-sync should not create repeated back-and-forth updates.
Actual result: both devices keep overwriting each other’s timezone and flood the request queue until the app becomes unresponsive.

What is the root cause of that problem?

The useAutoUpdateTimezone effect reacts to timezone?.selected changes and immediately re-sends updateAutomaticTimezone whenever local device timezone differs from the Onyx value. Since Onyx updates are cross-device, each device receives the other device’s timezone and then tries to “correct” it back to its own local timezone, causing an infinite ping-pong loop.

App/src/hooks/useAutoUpdateTimezone.ts

Lines 1 to 26 in ae3d89f

	import {useEffect} from 'react';
	import {updateAutomaticTimezone} from '@userActions/PersonalDetails';
	import type {SelectedTimezone} from '@src/types/onyx/PersonalDetails';
	import useCurrentUserPersonalDetails from './useCurrentUserPersonalDetails';
	const useAutoUpdateTimezone = () => {
	const currentUserPersonalDetails = useCurrentUserPersonalDetails();
	const timezone = currentUserPersonalDetails?.timezone ?? {};
	useEffect(() => {
	const currentTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone as SelectedTimezone;
	const hasValidCurrentTimezone = typeof currentTimezone === 'string' && currentTimezone.trim().length > 0;
	if (hasValidCurrentTimezone && timezone?.automatic && timezone?.selected !== currentTimezone) {
	updateAutomaticTimezone(
	{
	automatic: true,
	selected: currentTimezone,
	},
	currentUserPersonalDetails.accountID,
	);
	}
	// eslint-disable-next-line react-hooks/exhaustive-deps
	}, [timezone?.automatic, timezone?.selected]);
	};
	export default useAutoUpdateTimezone;

updateAutomaticTimezone writes optimistically to Onyx and syncs server-side, which propagates the changed timezone to other active sessions and retriggers the effect there.

App/src/libs/actions/PersonalDetails.ts

Lines 255 to 282 in ae3d89f

	/**
	* Updates timezone's 'automatic' setting, and updates
	* selected timezone if set to automatically update.
	*/
	function updateAutomaticTimezone(timezone: Timezone, currentUserAccountID: number) {
	if (!currentUserAccountID) {
	return;
	}
	const formattedTimezone = DateUtils.formatToSupportedTimezone(timezone);
	const parameters: UpdateAutomaticTimezoneParams = {
	timezone: JSON.stringify(formattedTimezone),
	};
	API.write(WRITE_COMMANDS.UPDATE_AUTOMATIC_TIMEZONE, parameters, {
	optimisticData: [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.PERSONAL_DETAILS_LIST,
	value: {
	[currentUserAccountID]: {
	timezone: formattedTimezone,
	},
	},
	},
	],
	});
	}

The hook is mounted globally in authenticated app flow, so every active session participates in this feedback loop.

App/src/libs/Navigation/AppNavigator/AuthScreens.tsx

Line 209 in ae3d89f

useAutoUpdateTimezone();

For copilot/delegate sessions specifically, we already have an account selector that can detect delegate mode and should prevent timezone writes from that session.

App/src/selectors/Account.ts

Line 4 in ae3d89f

const isActingAsDelegateSelector = (account: OnyxEntry<Account>) => !!account?.delegatedAccess?.delegate;

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

diff --git a/src/hooks/useAutoUpdateTimezone.ts b/src/hooks/useAutoUpdateTimezone.ts
--- a/src/hooks/useAutoUpdateTimezone.ts
+++ b/src/hooks/useAutoUpdateTimezone.ts
@@
 import {useEffect} from 'react';
+import useOnyx from '@hooks/useOnyx';
 import {updateAutomaticTimezone} from '@userActions/PersonalDetails';
+import {isActingAsDelegateSelector} from '@selectors/Account';
+import ONYXKEYS from '@src/ONYXKEYS';
 import type {SelectedTimezone} from '@src/types/onyx/PersonalDetails';
 import useCurrentUserPersonalDetails from './useCurrentUserPersonalDetails';
 
+const AUTO_TIMEZONE_UPDATE_THROTTLE_MS = 60 * 60 * 1000; // 1 hour
+let lastAutomaticTimezoneUpdateTimestamp = 0;
+
 const useAutoUpdateTimezone = () => {
     const currentUserPersonalDetails = useCurrentUserPersonalDetails();
+    const [isActingAsDelegate = false] = useOnyx(ONYXKEYS.ACCOUNT, {selector: isActingAsDelegateSelector});
     const timezone = currentUserPersonalDetails?.timezone ?? {};
+
     useEffect(() => {
+        // Copilot/delegate sessions must never change the primary account timezone.
+        if (isActingAsDelegate) {
+            return;
+        }
+
         const currentTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone as SelectedTimezone;
         const hasValidCurrentTimezone = typeof currentTimezone === 'string' && currentTimezone.trim().length > 0;
+        const now = Date.now();
+        const isThrottled = now - lastAutomaticTimezoneUpdateTimestamp < AUTO_TIMEZONE_UPDATE_THROTTLE_MS;
 
-        if (hasValidCurrentTimezone && timezone?.automatic && timezone?.selected !== currentTimezone) {
+        if (hasValidCurrentTimezone && timezone?.automatic && timezone?.selected !== currentTimezone && !isThrottled) {
             updateAutomaticTimezone(
                 {
                     automatic: true,
                     selected: currentTimezone,
                 },
                 currentUserPersonalDetails.accountID,
             );
+            lastAutomaticTimezoneUpdateTimestamp = now;
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [timezone?.automatic, timezone?.selected]);
+    }, [isActingAsDelegate, timezone?.automatic, timezone?.selected]);
 };
 
 export default useAutoUpdateTimezone;

[truph01]

🚨 Edited by proposal-police: This proposal was edited at 2026-03-01 05:52:16 UTC.

Proposal

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

• Infinite UpdateAutomaticTimezone loop when two devices are in different timezones

What is the root cause of that problem?

• The root cause is that the timezone update logic in useAutoUpdateTimezone always triggers when timezone?.selected changes:

Specifically:

1. Device A is in America/New_York, Device B is in Europe/London.
2. Both are logged into the same account with timezone.automatic = true.
3. Device A detects that timezone.selected !== 'America/New_York' and calls updateAutomaticTimezone().
   • Onyx optimistically sets selected: 'America/New_York'.
4. This Onyx update syncs to Device B via the server.
5. Device B's useEffect fires because timezone.selected changed.
   • It detects 'America/New_York' !== 'Europe/London' and calls updateAutomaticTimezone(), setting selected: 'Europe/London'.
6. That update syncs back to Device A, which again detects a mismatch and triggers another update.

Because timezone.selected is included in the dependency array, every remote sync re-triggers the effect. Since each device evaluates against its own local system timezone, they continuously override each other, resulting in an infinite loop.

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

1. Skip auto-timezone for copilot/delegate sessions — A copilot should never change the primary user's timezone. Check account?.delegatedAccess?.delegate (using isActingAsDelegateSelector from src/selectors/Account.ts) and bail out early.
   We should prevent the effect from re-triggering purely due to remote updates of timezone.selected.

2. Break the loop update: A straightforward approach is: Remove timezone?.selected and timezone?.automatic from the dependency array:

App/src/hooks/useAutoUpdateTimezone.ts

Line 23 in 1d43910

}, [timezone?.automatic, timezone?.selected]);

What alternative solutions did you explore? (Optional)

• Debouncing updateAutomaticTimezone
  Wrapping updateAutomaticTimezone in a debounce function was considered.

• Origin-aware updates (not yet implemented)
  Another potential approach would be to track whether a timezone update originated locally versus from a remote sync and ignore remote-triggered changes.