diff --git a/example/StackNavigator.tsx b/example/StackNavigator.tsx
index 8eef73e6..c9be5f16 100644
--- a/example/StackNavigator.tsx
+++ b/example/StackNavigator.tsx
@@ -115,9 +115,18 @@ const StackRouter = {
       case 'NAVIGATE':
         if (state.names.includes(action.payload.name)) {
           // If the route already exists, navigate to that
-          const index = state.routes.findIndex(
-            route => route.name === action.payload.name
-          );
+          let index = -1;
+
+          if (state.routes[state.index].name === action.payload.name) {
+            index = state.index;
+          } else {
+            for (let i = state.routes.length - 1; i >= 0; i--) {
+              if (state.routes[i].name === action.payload.name) {
+                index = i;
+                break;
+              }
+            }
+          }
 
           if (index === -1) {
             return StackRouter.reduce(state, {
@@ -161,13 +170,13 @@ const StackRouter = {
       }
 
       default:
-        return state;
+        return null;
     }
   },
 
   actions: {
-    push(name: string): Action {
-      return { type: 'PUSH', payload: { name } };
+    push(name: string, params?: object): Action {
+      return { type: 'PUSH', payload: { name, params } };
     },
     pop(): Action {
       return { type: 'POP' };
diff --git a/example/TabNavigator.tsx b/example/TabNavigator.tsx
index c6e617c0..b24cdb68 100644
--- a/example/TabNavigator.tsx
+++ b/example/TabNavigator.tsx
@@ -139,11 +139,8 @@ const TabRouter = {
 
         return null;
 
-      case 'GO_BACK':
-        return null;
-
       default:
-        return state;
+        return null;
     }
   },
 
diff --git a/example/index.tsx b/example/index.tsx
index 90fbd2a4..137f2f6b 100644
--- a/example/index.tsx
+++ b/example/index.tsx
@@ -6,6 +6,7 @@ import {
   Screen,
   CompositeNavigationProp,
   TypedNavigator,
+  NavigationHelpers,
 } from '../src';
 import StackNavigator, { StackNavigationProp } from './StackNavigator';
 import TabNavigator, { TabNavigationProp } from './TabNavigator';
@@ -34,7 +35,10 @@ const Tab: TypedNavigator<TabParamList, typeof TabNavigator> = {
 const First = ({
   navigation,
 }: {
-  navigation: StackNavigationProp<StackParamList, 'first'>;
+  navigation: CompositeNavigationProp<
+    StackNavigationProp<StackParamList, 'first'>,
+    NavigationHelpers<TabParamList>
+  >;
 }) => (
   <div>
     <h1>First, {navigation.state.params.author}</h1>
@@ -44,6 +48,9 @@ const First = ({
     <button type="button" onClick={() => navigation.push('third')}>
       Push third
     </button>
+    <button type="button" onClick={() => navigation.navigate('fourth')}>
+      Navigate to fourth
+    </button>
     <button
       type="button"
       onClick={() => navigation.navigate('first', { author: 'John' })}
@@ -59,7 +66,10 @@ const First = ({
 const Second = ({
   navigation,
 }: {
-  navigation: StackNavigationProp<StackParamList, 'second'>;
+  navigation: CompositeNavigationProp<
+    StackNavigationProp<StackParamList, 'second'>,
+    NavigationHelpers<TabParamList>
+  >;
 }) => (
   <div>
     <h1>Second</h1>
diff --git a/src/types.tsx b/src/types.tsx
index b05f75b5..8469c6c7 100644
--- a/src/types.tsx
+++ b/src/types.tsx
@@ -128,8 +128,8 @@ export type NavigationProp<
 };
 
 export type CompositeNavigationProp<
-  A extends NavigationProp<ParamListBase, string>,
-  B extends NavigationProp<ParamListBase, string>
+  A extends NavigationHelpers<ParamListBase>,
+  B extends NavigationHelpers<ParamListBase>
 > = Omit<A & B, keyof NavigationHelpers<any>> &
   NavigationHelpers<
     (A extends NavigationHelpers<infer T> ? T : never) &
diff --git a/src/useNavigationBuilder.tsx b/src/useNavigationBuilder.tsx
index da4b46a5..0201e1d2 100644
--- a/src/useNavigationBuilder.tsx
+++ b/src/useNavigationBuilder.tsx
@@ -17,10 +17,20 @@ type Options = {
   children: React.ReactNode;
 };
 
-export const NavigationHelpersContext = React.createContext<
+type HandleAction = (action: NavigationAction, fromKey: string) => boolean;
+
+const NavigationHelpersContext = React.createContext<
   NavigationHelpers | undefined
 >(undefined);
 
+const NavigationDispatchListenerContext = React.createContext<
+  ((listener: HandleAction) => void) | undefined
+>(undefined);
+
+const NavigationHandleActionContext = React.createContext<
+  HandleAction | undefined
+>(undefined);
+
 export default function useNavigationBuilder(router: Router, options: Options) {
   const screens = React.Children.map(options.children, child => {
     if (React.isValidElement(child) && child.type === Screen) {
@@ -49,6 +59,17 @@ export default function useNavigationBuilder(router: Router, options: Options) {
     setState,
   } = React.useContext(NavigationStateContext);
 
+  const parentNavigationHelpers = React.useContext(NavigationHelpersContext);
+  const dispatchListeners = React.useRef<HandleAction[]>([]);
+  const addDispatchListener = React.useCallback((listener: HandleAction) => {
+    dispatchListeners.current.push(listener);
+
+    return () => {
+      const index = dispatchListeners.current.indexOf(listener);
+      dispatchListeners.current.splice(index, 1);
+    };
+  }, []);
+
   const getState = React.useCallback(
     (): NavigationState =>
       router.initial({
@@ -60,24 +81,59 @@ export default function useNavigationBuilder(router: Router, options: Options) {
     [getCurrentState, ...routeNames]
   );
 
-  const parentNavigationHelpers = React.useContext(NavigationHelpersContext);
+  const onDispatch = React.useContext(NavigationDispatchListenerContext);
+  const handleActionParent = React.useContext(NavigationHandleActionContext);
+  const handleAction = React.useCallback(
+    (action: NavigationAction, fromKey?: string) => {
+      const state = getState();
+
+      // If the action was dispatched by this navigator, don't handle it
+      // This ensures that the action won't travel back up from children or down from parent
+      if (fromKey === state.key) {
+        return false;
+      }
+
+      const result = router.reduce(state, action);
+
+      if (result !== null) {
+        setState(result);
+        return true;
+      }
+
+      // If router returned `null`, it didn't handle it
+      // try to delegate the action to child navigators
+      for (let i = dispatchListeners.current.length - 1; i >= 0; i--) {
+        const listener = dispatchListeners.current[i];
+
+        if (listener(action, state.key)) {
+          return true;
+        }
+      }
+
+      if (handleActionParent !== undefined) {
+        // If non of the child navigators could handle the action, delegate it to parent
+        // This will enable sibling navigators to handle the action
+        if (handleActionParent(action, state.key)) {
+          return true;
+        }
+      }
+
+      return false;
+    },
+    [getState, handleActionParent, router, setState]
+  );
+
+  React.useEffect(() => onDispatch && onDispatch(handleAction), [
+    handleAction,
+    onDispatch,
+  ]);
 
   const helpers = React.useMemo((): NavigationHelpers => {
     const dispatch = (action: NavigationAction) => {
-      const state = getState();
-      const result = router.reduce(state, action);
-
-      // If router returned `null`, let the parent navigator handle it
-      if (result === null) {
-        if (parentNavigationHelpers !== undefined) {
-          parentNavigationHelpers.dispatch(action);
-        } else {
-          throw new Error(
-            `No navigators are able to handle the action "${action.type}".`
-          );
-        }
-      } else {
-        setState(result);
+      if (!handleAction(action)) {
+        throw new Error(
+          `No navigators are able to handle the action "${action.type}".`
+        );
       }
     };
 
@@ -99,7 +155,7 @@ export default function useNavigationBuilder(router: Router, options: Options) {
       ),
       dispatch,
     };
-  }, [router, parentNavigationHelpers, getState, setState]);
+  }, [handleAction, parentNavigationHelpers, router]);
 
   const navigation = React.useMemo(
     () => ({
@@ -117,13 +173,19 @@ export default function useNavigationBuilder(router: Router, options: Options) {
         render() {
           return (
             <NavigationHelpersContext.Provider value={helpers}>
-              <SceneView
-                helpers={helpers}
-                route={route}
-                screen={screen}
-                getState={getState}
-                setState={setState}
-              />
+              <NavigationHandleActionContext.Provider value={handleAction}>
+                <NavigationDispatchListenerContext.Provider
+                  value={addDispatchListener}
+                >
+                  <SceneView
+                    helpers={helpers}
+                    route={route}
+                    screen={screen}
+                    getState={getState}
+                    setState={setState}
+                  />
+                </NavigationDispatchListenerContext.Provider>
+              </NavigationHandleActionContext.Provider>
             </NavigationHelpersContext.Provider>
           );
         },