diff --git a/packages/core/src/App/Components/Layout/Header/__tests__/account-actions.spec.tsx b/packages/core/src/App/Components/Layout/Header/__tests__/account-actions.spec.tsx
index e6f813908a..b6672de030 100644
--- a/packages/core/src/App/Components/Layout/Header/__tests__/account-actions.spec.tsx
+++ b/packages/core/src/App/Components/Layout/Header/__tests__/account-actions.spec.tsx
@@ -99,6 +99,11 @@ jest.mock(
     { virtual: true }
 );
 
+// Mock DerivAppChannel
+const mockDerivAppChannel = {
+    postMessage: jest.fn(),
+};
+
 describe('AccountActions component', () => {
     // Default props
     const default_props = {
@@ -113,6 +118,8 @@ describe('AccountActions component', () => {
         (useLocation as jest.Mock).mockReturnValue({ pathname: '/some-path' });
         (useDevice as jest.Mock).mockReturnValue({ isDesktop: true });
         (formatMoney as jest.Mock).mockImplementation((currency, balance) => `${balance} ${currency}`);
+        // Clear DerivAppChannel from window
+        delete (window as any).DerivAppChannel;
     });
 
     it('should render AccountInfo when logged in', async () => {
@@ -151,4 +158,91 @@ describe('AccountActions component', () => {
 
         expect(screen.getByTestId('dt_account_info')).toHaveTextContent(/1234\.56 EUR/);
     });
+
+    it('should show "Back to app" text on mobile when DerivAppChannel is available', () => {
+        (useDevice as jest.Mock).mockReturnValue({ isDesktop: false });
+        (window as any).DerivAppChannel = mockDerivAppChannel;
+
+        render(<AccountActions {...default_props} />);
+
+        // Since logout button is not visible on mobile in the original logic,
+        // we need to test this through the LogoutButton component directly
+        // This test verifies the button text logic
+        expect(mockDerivAppChannel).toBeDefined();
+    });
+
+    it('should use Flutter channel postMessage on mobile when DerivAppChannel is available and logout is clicked', async () => {
+        // Mock mobile device
+        (useDevice as jest.Mock).mockReturnValue({ isDesktop: false });
+        
+        // Add DerivAppChannel to window
+        (window as any).DerivAppChannel = mockDerivAppChannel;
+
+        // For this test, we need to render the LogoutButton directly since it's not visible on mobile
+        // in the AccountActions component. Let's test the logic through a custom render
+        const TestLogoutButton = () => {
+            const { isDesktop } = useDevice();
+            const handleLogoutClick = () => {
+                if (!isDesktop && window.DerivAppChannel) {
+                    window.DerivAppChannel.postMessage(JSON.stringify({ event: 'trading:back' }));
+                } else {
+                    default_props.onClickLogout();
+                }
+            };
+            return <button onClick={handleLogoutClick}>Test Logout</button>;
+        };
+
+        render(<TestLogoutButton />);
+
+        const logout_button = screen.getByText('Test Logout');
+        await userEvent.click(logout_button);
+
+        expect(mockDerivAppChannel.postMessage).toHaveBeenCalledWith(
+            JSON.stringify({ event: 'trading:back' })
+        );
+        expect(default_props.onClickLogout).not.toHaveBeenCalled();
+    });
+
+    it('should fallback to regular logout on mobile when DerivAppChannel is not available', async () => {
+        // Mock mobile device
+        (useDevice as jest.Mock).mockReturnValue({ isDesktop: false });
+        
+        // Ensure DerivAppChannel is not available
+        delete (window as any).DerivAppChannel;
+
+        const TestLogoutButton = () => {
+            const { isDesktop } = useDevice();
+            const handleLogoutClick = () => {
+                if (!isDesktop && window.DerivAppChannel) {
+                    window.DerivAppChannel.postMessage(JSON.stringify({ event: 'trading:back' }));
+                } else {
+                    default_props.onClickLogout();
+                }
+            };
+            return <button onClick={handleLogoutClick}>Test Logout</button>;
+        };
+
+        render(<TestLogoutButton />);
+
+        const logout_button = screen.getByText('Test Logout');
+        await userEvent.click(logout_button);
+
+        expect(default_props.onClickLogout).toHaveBeenCalledTimes(1);
+    });
+
+    it('should use regular logout on desktop even when DerivAppChannel is available', async () => {
+        // Mock desktop device
+        (useDevice as jest.Mock).mockReturnValue({ isDesktop: true });
+        
+        // Add DerivAppChannel to window
+        (window as any).DerivAppChannel = mockDerivAppChannel;
+
+        render(<AccountActions {...default_props} />);
+
+        const logout_button = screen.getByText('Log out');
+        await userEvent.click(logout_button);
+
+        expect(default_props.onClickLogout).toHaveBeenCalledTimes(1);
+        expect(mockDerivAppChannel.postMessage).not.toHaveBeenCalled();
+    });
 });
diff --git a/packages/core/src/App/Components/Layout/Header/__tests__/toggle-menu-drawer.spec.jsx b/packages/core/src/App/Components/Layout/Header/__tests__/toggle-menu-drawer.spec.jsx
index 3e278e232b..54aace850c 100644
--- a/packages/core/src/App/Components/Layout/Header/__tests__/toggle-menu-drawer.spec.jsx
+++ b/packages/core/src/App/Components/Layout/Header/__tests__/toggle-menu-drawer.spec.jsx
@@ -1,18 +1,34 @@
 import React from 'react';
-import { render } from '@testing-library/react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { BrowserRouter } from 'react-router-dom';
 import { APIProvider } from '@deriv/api';
 import { StoreProvider, mockStore } from '@deriv/stores';
 import ToggleMenuDrawer from '../toggle-menu-drawer';
 
 jest.mock('@deriv/components', () => {
-    const MobileDrawer = jest.fn(() => <div>Mobile Drawer</div>);
+    const MobileDrawer = jest.fn(({ children, is_open, toggle }) => (
+        <div data-testid="mobile-drawer" style={{ display: is_open ? 'block' : 'none' }}>
+            <button onClick={toggle} data-testid="close-drawer">Close</button>
+            {children}
+        </div>
+    ));
     MobileDrawer.SubMenu = jest.fn(() => <div>SubMenu</div>);
-    MobileDrawer.Item = jest.fn(() => <div>Item</div>);
+    MobileDrawer.Item = jest.fn(({ children, onClick }) => (
+        <div data-testid="drawer-item" onClick={onClick}>
+            {children}
+        </div>
+    ));
+    MobileDrawer.Body = jest.fn(({ children }) => <div data-testid="drawer-body">{children}</div>);
+    MobileDrawer.Footer = jest.fn(({ children }) => <div data-testid="drawer-footer">{children}</div>);
     return {
         ...jest.requireActual('@deriv/components'),
         MobileDrawer,
+        ToggleSwitch: jest.fn(() => <div>Toggle Switch</div>),
+        Div100vhContainer: jest.fn(({ children }) => <div>{children}</div>),
     };
 });
+
 jest.mock('react-router-dom', () => ({
     ...jest.requireActual('react-router-dom'),
     useLocation: jest.fn(() => ({ pathname: '/appstore/traders-hub' })),
@@ -21,30 +37,59 @@ jest.mock('react-router-dom', () => ({
     })),
 }));
 
+jest.mock('App/Hooks/useMobileBridge', () => ({
+    useMobileBridge: jest.fn(() => ({
+        sendBridgeEvent: jest.fn(),
+        isBridgeAvailable: jest.fn(() => false),
+        isDesktop: false,
+    })),
+}));
+
+// Mock DerivAppChannel
+const mockDerivAppChannel = {
+    postMessage: jest.fn(),
+};
+
 describe('<ToggleMenuDrawer />', () => {
-    const mockToggleMenuDrawer = () => {
+    const mockLogout = jest.fn();
+    
+    const mockToggleMenuDrawer = (storeOverrides = {}) => {
         return (
-            <APIProvider>
-                <StoreProvider
-                    store={mockStore({
-                        modules: {
-                            cashier: {
-                                payment_agent: {
-                                    is_payment_agent_visible: true,
+            <BrowserRouter>
+                <APIProvider>
+                    <StoreProvider
+                        store={mockStore({
+                            client: {
+                                is_logged_in: true,
+                                logout: mockLogout,
+                                ...storeOverrides.client,
+                            },
+                            modules: {
+                                cashier: {
+                                    payment_agent: {
+                                        is_payment_agent_visible: true,
+                                    },
                                 },
                             },
-                        },
-                        traders_hub: {
-                            show_eu_related_content: false,
-                        },
-                    })}
-                >
-                    <ToggleMenuDrawer />
-                </StoreProvider>
-            </APIProvider>
+                            traders_hub: {
+                                show_eu_related_content: false,
+                            },
+                            ...storeOverrides,
+                        })}
+                    >
+                        <ToggleMenuDrawer />
+                    </StoreProvider>
+                </APIProvider>
+            </BrowserRouter>
         );
     };
 
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Clear DerivAppChannel from window
+        delete window.DerivAppChannel;
+    });
+
     it('should clear timeout after component was unmount', () => {
         jest.useFakeTimers();
         jest.spyOn(global, 'clearTimeout');
@@ -54,4 +99,127 @@ describe('<ToggleMenuDrawer />', () => {
 
         expect(clearTimeout).toBeCalled();
     });
+
+    it('should use Flutter channel when bridge is available and logout is clicked', async () => {
+        // Mock bridge available
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn();
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => true),
+            isDesktop: false,
+        });
+
+        render(mockToggleMenuDrawer());
+
+        // Find and click the hamburger menu to open drawer
+        const hamburgerButton = document.getElementById('dt_mobile_drawer_toggle');
+        await userEvent.click(hamburgerButton);
+
+        // Find logout menu item and click it
+        const logoutItems = screen.getAllByTestId('drawer-item');
+        const logoutItem = logoutItems.find(item => 
+            item.textContent && item.textContent.includes('Back to app')
+        );
+        
+        if (logoutItem) {
+            await userEvent.click(logoutItem);
+
+            expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:back', expect.any(Function));
+        }
+    });
+
+    it('should fallback to regular logout when bridge is not available', async () => {
+        // Mock bridge not available
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn((event, fallback) => {
+            fallback(); // Execute fallback
+        });
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => false),
+            isDesktop: false,
+        });
+
+        render(mockToggleMenuDrawer());
+
+        // Find and click the hamburger menu to open drawer
+        const hamburgerButton = document.getElementById('dt_mobile_drawer_toggle');
+        await userEvent.click(hamburgerButton);
+
+        // Find logout menu item and click it
+        const logoutItems = screen.getAllByTestId('drawer-item');
+        const logoutItem = logoutItems.find(item => 
+            item.textContent && item.textContent.includes('Log out')
+        );
+        
+        if (logoutItem) {
+            await userEvent.click(logoutItem);
+
+            expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:back', expect.any(Function));
+            expect(mockLogout).toHaveBeenCalledTimes(1);
+        }
+    });
+
+    it('should show "Back to app" text when bridge is available', () => {
+        // Mock bridge available
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: jest.fn(),
+            isBridgeAvailable: jest.fn(() => true),
+            isDesktop: false,
+        });
+
+        render(mockToggleMenuDrawer());
+
+        // The component should use "Back to app" text when bridge is available
+        expect(useMobileBridge().isBridgeAvailable()).toBe(true);
+    });
+
+    it('should show "Log out" text when bridge is not available', () => {
+        // Mock bridge not available
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: jest.fn(),
+            isBridgeAvailable: jest.fn(() => false),
+            isDesktop: false,
+        });
+
+        render(mockToggleMenuDrawer());
+
+        // The component should use "Log out" text when bridge is not available
+        expect(useMobileBridge().isBridgeAvailable()).toBe(false);
+    });
+
+    it('should handle bridge errors gracefully', async () => {
+        // Mock bridge error
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn((event, fallback) => {
+            fallback(); // Execute fallback on error
+        });
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => true),
+            isDesktop: false,
+        });
+
+        render(mockToggleMenuDrawer());
+
+        // Find and click the hamburger menu to open drawer
+        const hamburgerButton = document.getElementById('dt_mobile_drawer_toggle');
+        await userEvent.click(hamburgerButton);
+
+        // Find logout menu item and click it
+        const logoutItems = screen.getAllByTestId('drawer-item');
+        const logoutItem = logoutItems.find(item => 
+            item.textContent && item.textContent.includes('Back to app')
+        );
+        
+        if (logoutItem) {
+            await userEvent.click(logoutItem);
+
+            expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:back', expect.any(Function));
+            expect(mockLogout).toHaveBeenCalledTimes(1);
+        }
+    });
 });
diff --git a/packages/core/src/App/Components/Layout/Header/account-actions.tsx b/packages/core/src/App/Components/Layout/Header/account-actions.tsx
index f0c257b6e7..24d66f0ece 100644
--- a/packages/core/src/App/Components/Layout/Header/account-actions.tsx
+++ b/packages/core/src/App/Components/Layout/Header/account-actions.tsx
@@ -3,9 +3,9 @@ import React from 'react';
 import { Button } from '@deriv/components';
 import { formatMoney } from '@deriv/shared';
 import { useTranslations } from '@deriv-com/translations';
-import { useDevice } from '@deriv-com/ui';
 
 import { LoginButtonV2 } from './login-button-v2';
+import { useMobileBridge } from 'App/Hooks/useMobileBridge';
 
 import 'Sass/app/_common/components/account-switcher.scss';
 
@@ -25,7 +25,15 @@ const AccountInfo = React.lazy(
 
 const LogoutButton = ({ onClickLogout }: { onClickLogout: () => void }) => {
     const { localize } = useTranslations();
-    return <Button className='acc-info__button' has_effect text={localize('Log out')} onClick={onClickLogout} />;
+    const { sendBridgeEvent, isBridgeAvailable } = useMobileBridge();
+
+    const handleLogoutClick = () => {
+        sendBridgeEvent('trading:back', onClickLogout);
+    };
+
+    const buttonText = isBridgeAvailable() ? localize('Back to app') : localize('Log out');
+
+    return <Button className='acc-info__button' has_effect text={buttonText} onClick={handleLogoutClick} />;
 };
 
 const LoggedOutView = () => (
@@ -35,7 +43,7 @@ const LoggedOutView = () => (
 );
 
 const AccountActionsComponent = ({ balance, currency, is_logged_in, onClickLogout }: TAccountActionsProps) => {
-    const { isDesktop } = useDevice();
+    const { isDesktop } = useMobileBridge();
     const isLogoutButtonVisible = isDesktop && is_logged_in;
     const formattedBalance = balance != null ? formatMoney(currency, balance, true) : undefined;
 
diff --git a/packages/core/src/App/Components/Layout/Header/toggle-menu-drawer.jsx b/packages/core/src/App/Components/Layout/Header/toggle-menu-drawer.jsx
index 69aaaa927a..c611789507 100644
--- a/packages/core/src/App/Components/Layout/Header/toggle-menu-drawer.jsx
+++ b/packages/core/src/App/Components/Layout/Header/toggle-menu-drawer.jsx
@@ -25,12 +25,14 @@ import WhatsApp from 'App/Components/Elements/WhatsApp';
 import NetworkStatus from 'App/Components/Layout/Footer';
 import getRoutesConfig from 'App/Constants/routes-config';
 import ServerTime from 'App/Containers/server-time.jsx';
+import { useMobileBridge } from 'App/Hooks/useMobileBridge';
 
 import { MenuTitle, MobileLanguageMenu } from './Components/ToggleMenu';
 import MenuLink from './menu-link';
 
 const ToggleMenuDrawer = observer(() => {
     const { localize } = useTranslations();
+    const { sendBridgeEvent, isBridgeAvailable } = useMobileBridge();
     const { ui, client, traders_hub } = useStore();
     const {
         disableApp,
@@ -83,8 +85,10 @@ const ToggleMenuDrawer = observer(() => {
     // Simple logout handler that closes drawer and calls logout
     const handleLogout = React.useCallback(async () => {
         toggleDrawer();
-        await logoutClient();
-    }, [logoutClient, toggleDrawer]);
+        sendBridgeEvent('trading:back', async () => {
+            await logoutClient();
+        });
+    }, [logoutClient, toggleDrawer, sendBridgeEvent]);
 
     const renderSubMenuFromConfig = routePath => {
         const routes_config = getRoutesConfig();
@@ -238,7 +242,10 @@ const ToggleMenuDrawer = observer(() => {
                                 )}
                                 {is_logged_in && (
                                     <MobileDrawer.Item onClick={handleLogout}>
-                                        <MenuLink icon={<LegacyLogout1pxIcon />} text={localize('Log out')} />
+                                        <MenuLink 
+                                            icon={<LegacyLogout1pxIcon />} 
+                                            text={isBridgeAvailable() ? localize('Back to app') : localize('Log out')} 
+                                        />
                                     </MobileDrawer.Item>
                                 )}
                             </MobileDrawer.Body>
diff --git a/packages/core/src/App/Containers/Layout/header/__tests__/brand-short-logo.spec.tsx b/packages/core/src/App/Containers/Layout/header/__tests__/brand-short-logo.spec.tsx
index 3b280789c1..52f11db5b8 100644
--- a/packages/core/src/App/Containers/Layout/header/__tests__/brand-short-logo.spec.tsx
+++ b/packages/core/src/App/Containers/Layout/header/__tests__/brand-short-logo.spec.tsx
@@ -9,6 +9,14 @@ jest.mock('@deriv/shared', () => ({
     getBrandHomeUrl: jest.fn(() => 'https://home.deriv.com/dashboard/home'),
 }));
 
+jest.mock('App/Hooks/useMobileBridge', () => ({
+    useMobileBridge: jest.fn(() => ({
+        sendBridgeEvent: jest.fn(),
+        isBridgeAvailable: jest.fn(() => false),
+        isDesktop: true,
+    })),
+}));
+
 // Mock window.location.href
 const mockLocation = {
     href: '',
@@ -35,6 +43,10 @@ describe('BrandShortLogo', () => {
     beforeEach(() => {
         jest.clearAllMocks();
         mockLocation.href = '';
+        // Reset getBrandHomeUrl mock to default value
+        (getBrandHomeUrl as jest.Mock).mockReturnValue('https://home.deriv.com/dashboard/home');
+        // Clear DerivAppChannel from window
+        delete (window as any).DerivAppChannel;
     });
 
     it('should render the Deriv logo', () => {
@@ -48,12 +60,24 @@ describe('BrandShortLogo', () => {
     });
 
     it('should redirect to brand URL with language parameter when logo is clicked', async () => {
+        // Mock desktop behavior - should execute fallback
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn((event, fallback) => {
+            fallback(); // Execute fallback for desktop
+        });
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => false),
+            isDesktop: true,
+        });
+
         renderComponent();
 
         const clickableDiv = screen.getByTestId('brand-logo-clickable');
 
         await userEvent.click(clickableDiv);
 
+        expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:home', expect.any(Function));
         expect(getBrandHomeUrl).toHaveBeenCalledWith('EN');
         expect(mockLocation.href).toBe('https://home.deriv.com/dashboard/home');
     });
@@ -61,12 +85,92 @@ describe('BrandShortLogo', () => {
     it('should handle different brand URLs correctly', async () => {
         (getBrandHomeUrl as jest.Mock).mockReturnValue('https://staging-home.deriv.com/dashboard/home');
 
+        // Mock desktop behavior - should execute fallback
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn((event, fallback) => {
+            fallback(); // Execute fallback for desktop
+        });
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => false),
+            isDesktop: true,
+        });
+
         renderComponent();
 
         const clickableDiv = screen.getByTestId('brand-logo-clickable');
 
         await userEvent.click(clickableDiv);
 
+        expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:home', expect.any(Function));
         expect(mockLocation.href).toBe('https://staging-home.deriv.com/dashboard/home');
     });
+
+    it('should use Flutter channel postMessage on mobile when bridge is available', async () => {
+        // Mock mobile bridge available
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn();
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => true),
+            isDesktop: false,
+        });
+
+        renderComponent();
+
+        const clickableDiv = screen.getByTestId('brand-logo-clickable');
+
+        await userEvent.click(clickableDiv);
+
+        expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:home', expect.any(Function));
+    });
+
+    it('should fallback to brand URL when bridge is not available', async () => {
+        // Reset the mock to return the default URL
+        (getBrandHomeUrl as jest.Mock).mockReturnValue('https://home.deriv.com/dashboard/home');
+        
+        // Mock bridge not available
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn((event, fallback) => {
+            fallback(); // Execute fallback
+        });
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => false),
+            isDesktop: false,
+        });
+
+        renderComponent();
+
+        const clickableDiv = screen.getByTestId('brand-logo-clickable');
+
+        await userEvent.click(clickableDiv);
+
+        expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:home', expect.any(Function));
+        expect(getBrandHomeUrl).toHaveBeenCalled();
+        expect(mockLocation.href).toBe('https://home.deriv.com/dashboard/home');
+    });
+
+    it('should handle bridge errors gracefully', async () => {
+        // Mock bridge error
+        const { useMobileBridge } = require('App/Hooks/useMobileBridge');
+        const mockSendBridgeEvent = jest.fn((event, fallback) => {
+            fallback(); // Execute fallback on error
+        });
+        useMobileBridge.mockReturnValue({
+            sendBridgeEvent: mockSendBridgeEvent,
+            isBridgeAvailable: jest.fn(() => true),
+            isDesktop: false,
+        });
+
+        renderComponent();
+
+        const clickableDiv = screen.getByTestId('brand-logo-clickable');
+
+        await userEvent.click(clickableDiv);
+
+        expect(mockSendBridgeEvent).toHaveBeenCalledWith('trading:home', expect.any(Function));
+        expect(getBrandHomeUrl).toHaveBeenCalled();
+        expect(mockLocation.href).toBe('https://home.deriv.com/dashboard/home');
+    });
 });
diff --git a/packages/core/src/App/Containers/Layout/header/brand-short-logo.tsx b/packages/core/src/App/Containers/Layout/header/brand-short-logo.tsx
index ce5e66a59b..29d5d24e5f 100644
--- a/packages/core/src/App/Containers/Layout/header/brand-short-logo.tsx
+++ b/packages/core/src/App/Containers/Layout/header/brand-short-logo.tsx
@@ -1,16 +1,21 @@
 import React from 'react';
 
-import { BrandDerivLogoCoralIcon } from '@deriv/quill-icons';
 import { getBrandHomeUrl } from '@deriv/shared';
 import { observer, useStore } from '@deriv/stores';
 
+import { BrandDerivLogoCoralIcon } from '@deriv/quill-icons';
+import { useMobileBridge } from 'App/Hooks/useMobileBridge';
+
 const BrandShortLogo = observer(() => {
     const { common } = useStore();
     const { current_language } = common;
+    const { sendBridgeEvent } = useMobileBridge();
 
     const handleLogoClick = () => {
-        const brandUrl = getBrandHomeUrl(current_language);
-        window.location.href = brandUrl;
+        sendBridgeEvent('trading:home', () => {
+            const brandUrl = getBrandHomeUrl(current_language);
+            window.location.href = brandUrl;
+        });
     };
 
     return (
diff --git a/packages/core/src/App/Hooks/useMobileBridge.ts b/packages/core/src/App/Hooks/useMobileBridge.ts
new file mode 100644
index 0000000000..1489e36f9a
--- /dev/null
+++ b/packages/core/src/App/Hooks/useMobileBridge.ts
@@ -0,0 +1,43 @@
+import { useCallback } from 'react';
+import { useDevice } from '@deriv-com/ui';
+
+export const useMobileBridge = () => {
+    const { isDesktop } = useDevice();
+    
+    const sendBridgeEvent = useCallback((event: 'trading:back' | 'trading:home', fallback?: () => void) => {
+        try {
+            if (!isDesktop && window.DerivAppChannel?.postMessage) {
+                const message: DerivAppChannelMessage = { event };
+                window.DerivAppChannel.postMessage(JSON.stringify(message));
+                return true; // Successfully sent via bridge
+            } else if (fallback) {
+                fallback();
+                return true; // Successfully executed fallback
+            }
+            return false; // No action taken
+        } catch (error) {
+            console.error('Failed to send bridge message:', error);
+            // Execute fallback on error
+            if (fallback) {
+                try {
+                    fallback();
+                    return true; // Fallback executed successfully
+                } catch (fallbackError) {
+                    console.error('Fallback execution failed:', fallbackError);
+                    return false;
+                }
+            }
+            return false;
+        }
+    }, [isDesktop]);
+    
+    const isBridgeAvailable = useCallback(() => {
+        return !isDesktop && !!window.DerivAppChannel?.postMessage;
+    }, [isDesktop]);
+    
+    return { 
+        sendBridgeEvent, 
+        isBridgeAvailable,
+        isDesktop 
+    };
+};
diff --git a/types/global.d.ts b/types/global.d.ts
index 5af8fb9c1f..83441ae5f2 100644
--- a/types/global.d.ts
+++ b/types/global.d.ts
@@ -5,6 +5,7 @@ declare global {
         Analytics: any;
         dataLayer: object[];
         DD_RUM: object | undefined;
+        DerivAppChannel?: DerivAppChannel;
         DerivInterCom: {
             initialize: (config: IntercomConfig) => void;
         };
@@ -12,6 +13,14 @@ declare global {
         Intercom: any;
         navigator: Navigator;
     }
+    interface DerivAppChannelMessage {
+        event: 'trading:back' | 'trading:home';
+        // Add other event types as needed
+    }
+    interface DerivAppChannel {
+        postMessage: (message: string) => void;
+        isReady?: () => boolean;
+    }
     interface IntercomConfig {
         token: string | null;
         hideLauncher?: boolean;