diff --git a/go/test/endtoend/vtgate/gen4/gen4_test.go b/go/test/endtoend/vtgate/gen4/gen4_test.go
index ff18795fb5e..a242ef0bb7a 100644
--- a/go/test/endtoend/vtgate/gen4/gen4_test.go
+++ b/go/test/endtoend/vtgate/gen4/gen4_test.go
@@ -520,40 +520,3 @@ func TestDualJoinQueries(t *testing.T) {
 	mcmp.Exec("select t.title, t2.id from t2 left join (select 'ABC' as title) as t on t.title = t2.tcol1")
 
 }
-
-// TestSchemaTrackingGlobalTables tests that schema tracking works as intended with global table routing.
-// This test creates a new table in a schema and verifies we can query it without needing to add it to the vschema as long
-// as the name of the table is unique. It also creates a table which is already in the vschema to ensure that we
-// don't mark it as ambiguous when schema tracking also finds it.
-func TestSchemaTrackingGlobalTables(t *testing.T) {
-	// Create a new vtgate connection.
-	tables := []string{"uniqueTableName", "t1"}
-	for _, table := range tables {
-		t.Run(table, func(t *testing.T) {
-			vtConn, err := mysql.Connect(context.Background(), &vtParams)
-			require.NoError(t, err)
-			defer vtConn.Close()
-
-			// Create a new table in the unsharded keyspace such that it has a unique name that allows for global routing.
-			utils.Exec(t, vtConn, `use `+unshardedKs)
-			// Use the same schema as t1 from sharded_schema.sql
-			utils.Exec(t, vtConn, fmt.Sprintf(`create table if not exists %s(id bigint, col bigint, primary key(id))`, table))
-			defer utils.Exec(t, vtConn, fmt.Sprintf(`drop table %s`, table))
-
-			// Wait for schema tracking to see this column.
-			err = utils.WaitForAuthoritative(t, unshardedKs, table, clusterInstance.VtgateProcess.ReadVSchema)
-			require.NoError(t, err)
-
-			// Create a new vtgate connection.
-			vtConn2, err := mysql.Connect(context.Background(), &vtParams)
-			require.NoError(t, err)
-			defer vtConn2.Close()
-
-			// Insert rows into the table and select them to verify we can use them.
-			utils.Exec(t, vtConn2, fmt.Sprintf(`insert into %s(id, col) values (10, 100),(20, 200)`, table))
-			require.NoError(t, err)
-			utils.AssertMatches(t, vtConn2, fmt.Sprintf(`select * from %s order by id`, table),
-				`[[INT64(10) INT64(100)] [INT64(20) INT64(200)]]`)
-		})
-	}
-}
diff --git a/go/test/endtoend/vtgate/gen4/main_test.go b/go/test/endtoend/vtgate/gen4/main_test.go
index 4c94e8e2ec8..ca288be4b64 100644
--- a/go/test/endtoend/vtgate/gen4/main_test.go
+++ b/go/test/endtoend/vtgate/gen4/main_test.go
@@ -61,6 +61,13 @@ var (
   }
 ]}
 `
+	unsharded2Ks = "uks2"
+
+	//go:embed unsharded2_schema.sql
+	unsharded2SchemaSQL string
+
+	//go:embed unsharded2_vschema.json
+	unsharded2VSchema string
 )
 
 func TestMain(m *testing.M) {
@@ -101,6 +108,16 @@ func TestMain(m *testing.M) {
 			return 1
 		}
 
+		uKs2 := &cluster.Keyspace{
+			Name:      unsharded2Ks,
+			SchemaSQL: unsharded2SchemaSQL,
+			VSchema:   unsharded2VSchema,
+		}
+		err = clusterInstance.StartUnshardedKeyspace(*uKs2, 0, false)
+		if err != nil {
+			return 1
+		}
+
 		// apply routing rules
 		err = clusterInstance.VtctldClientProcess.ApplyRoutingRules(routingRules)
 		if err != nil {
diff --git a/go/test/endtoend/vtgate/gen4/unsharded2_schema.sql b/go/test/endtoend/vtgate/gen4/unsharded2_schema.sql
new file mode 100644
index 00000000000..c3df5bd0a56
--- /dev/null
+++ b/go/test/endtoend/vtgate/gen4/unsharded2_schema.sql
@@ -0,0 +1,13 @@
+create table u2_a
+(
+    id bigint,
+    a  bigint,
+    primary key (id)
+) Engine = InnoDB;
+
+create table u2_b
+(
+    id bigint,
+    b  varchar(50),
+    primary key (id)
+) Engine = InnoDB;
diff --git a/go/test/endtoend/vtgate/gen4/unsharded2_vschema.json b/go/test/endtoend/vtgate/gen4/unsharded2_vschema.json
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/go/vt/vtgate/vindexes/vschema.go b/go/vt/vtgate/vindexes/vschema.go
index e36289132c5..1847dd0539e 100644
--- a/go/vt/vtgate/vindexes/vschema.go
+++ b/go/vt/vtgate/vindexes/vschema.go
@@ -356,7 +356,7 @@ func BuildVSchema(source *vschemapb.SrvVSchema, parser *sqlparser.Parser) (vsche
 	buildKeyspaces(source, vschema, parser)
 	// buildGlobalTables before buildReferences so that buildReferences can
 	// resolve sources which reference global tables.
-	BuildGlobalTables(source, vschema, false)
+	BuildGlobalTables(source, vschema)
 	buildReferences(source, vschema)
 	buildRoutingRule(source, vschema, parser)
 	buildShardRoutingRule(source, vschema)
@@ -461,7 +461,7 @@ func (vschema *VSchema) AddUDF(ksname, udfName string) error {
 	return nil
 }
 
-func BuildGlobalTables(source *vschemapb.SrvVSchema, vschema *VSchema, skipIfAlreadyGlobal bool) {
+func BuildGlobalTables(source *vschemapb.SrvVSchema, vschema *VSchema) {
 	for ksname, ks := range source.Keyspaces {
 		ksvschema := vschema.Keyspaces[ksname]
 		// If the keyspace requires explicit routing, don't include any of
@@ -469,19 +469,55 @@ func BuildGlobalTables(source *vschemapb.SrvVSchema, vschema *VSchema, skipIfAlr
 		if ks.RequireExplicitRouting {
 			continue
 		}
-		buildKeyspaceGlobalTables(vschema, ksvschema, skipIfAlreadyGlobal)
+		buildKeyspaceGlobalTables(vschema, ksvschema)
 	}
 }
 
-func buildKeyspaceGlobalTables(vschema *VSchema, ksvschema *KeyspaceSchema, skipIfAlreadyGlobal bool) {
+// AddAdditionalGlobalTables adds unique tables from unsharded keyspaces to the global tables.
+// It is expected to be called from the schema tracking code.
+func AddAdditionalGlobalTables(source *vschemapb.SrvVSchema, vschema *VSchema) {
+	type tableInfo struct {
+		table *Table
+		cnt   int
+	}
+	newTables := make(map[string]*tableInfo)
+
+	// Collect valid uniquely named tables from unsharded keyspaces.
+	for ksname, ks := range source.Keyspaces {
+		ksvschema := vschema.Keyspaces[ksname]
+		// Ignore sharded keyspaces and those flagged for explicit routing.
+		if ks.RequireExplicitRouting || ks.Sharded {
+			continue
+		}
+		for tname, table := range ksvschema.Tables {
+			// Ignore tables already global or ambiguous.
+			if _, found := vschema.globalTables[tname]; !found {
+				_, ok := newTables[tname]
+				if !ok {
+					table.Keyspace = &Keyspace{Name: ksname}
+					newTables[tname] = &tableInfo{table: table, cnt: 0}
+				}
+				newTables[tname].cnt++
+			}
+		}
+	}
+
+	// Mark new tables found just once as globally routable, rest as ambiguous.
+	for tname, ti := range newTables {
+		switch ti.cnt {
+		case 1:
+			vschema.globalTables[tname] = ti.table
+		default:
+			vschema.globalTables[tname] = nil
+		}
+	}
+}
+
+func buildKeyspaceGlobalTables(vschema *VSchema, ksvschema *KeyspaceSchema) {
 	for tname, t := range ksvschema.Tables {
 		if gt, ok := vschema.globalTables[tname]; ok {
 			// There is already an entry table stored in global tables
 			// with this name.
-			if skipIfAlreadyGlobal {
-				// Called when updating from schema tracking
-				continue
-			}
 			if gt == nil {
 				// Table name is already marked ambiguous, nothing to do.
 				continue
diff --git a/go/vt/vtgate/vindexes/vschema_routing_test.go b/go/vt/vtgate/vindexes/vschema_routing_test.go
new file mode 100644
index 00000000000..be1f6f21989
--- /dev/null
+++ b/go/vt/vtgate/vindexes/vschema_routing_test.go
@@ -0,0 +1,289 @@
+package vindexes
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	vschemapb "vitess.io/vitess/go/vt/proto/vschema"
+	"vitess.io/vitess/go/vt/sqlparser"
+)
+
+// TestAutoGlobalRouting tests adding tables in unsharded keyspaces to global routing if they don't have
+// an associated VSchema which has the RequireExplicitRouting flag set. These tables should also not be
+// already part of the global routing tables via the VSchema of sharded keyspaces.
+func TestAutoGlobalRouting(t *testing.T) {
+	// Create two unsharded keyspaces and two sharded keyspaces, each with some common tables.
+	unsharded1 := &vschemapb.Keyspace{
+		Tables: map[string]*vschemapb.Table{
+			"table1":   {}, // unique, should be added to global routing
+			"table2":   {}, // unique, should be added to global routing
+			"scommon1": {}, // common with sharded1, should not be added to global routing because it is already global because of sharded1
+			"ucommon3": {}, // common with unsharded2, should not be added to global routing because it is ambiguous because of unsharded2
+		},
+	}
+	unsharded2 := &vschemapb.Keyspace{
+		Tables: map[string]*vschemapb.Table{
+			"table3":   {}, // unique, should be added to global routing
+			"table4":   {}, // unique, should be added to global routing
+			"scommon1": {}, // common with sharded1, should not be added to global routing because it is already global because of sharded1
+			"scommon2": {}, // common with sharded1, should not be added to global routing because it is already global because of sharded1
+			"ucommon3": {}, // common with unsharded1, should not be added to global routing because it is ambiguous because of unsharded1
+		},
+	}
+	sharded1 := &vschemapb.Keyspace{
+		Sharded: true,
+		Vindexes: map[string]*vschemapb.Vindex{
+			"xxhash": {
+				Type: "xxhash",
+			},
+		},
+		Tables: map[string]*vschemapb.Table{
+			"table5":   {}, // unique, should be added to global routing
+			"scommon1": {}, // common with unsharded1 and unsharded2, should be added to global routing because it's in the vschema
+			"scommon2": {}, // common with unsharded2, ambiguous because of sharded2
+		},
+	}
+	sharded2 := &vschemapb.Keyspace{
+		Sharded:                true,
+		RequireExplicitRouting: true,
+		Vindexes: map[string]*vschemapb.Vindex{
+			"xxhash": {
+				Type: "xxhash",
+			},
+		},
+		// none should be considered for choice as global or ambiguous because of RequireExplicitRouting
+		Tables: map[string]*vschemapb.Table{
+			"table6":   {}, // unique
+			"scommon2": {}, // common with sharded2, but has RequireExplicitRouting
+			"scommon3": {}, // common with sharded2
+		},
+	}
+	for _, ks := range []*vschemapb.Keyspace{sharded1, sharded2} {
+		for _, t := range ks.Tables {
+			t.ColumnVindexes = append(t.ColumnVindexes, &vschemapb.ColumnVindex{
+				Column: "c1",
+				Name:   "xxhash",
+			})
+		}
+	}
+	source := &vschemapb.SrvVSchema{
+		Keyspaces: map[string]*vschemapb.Keyspace{
+			"sharded1": sharded1,
+			"sharded2": sharded2,
+		},
+	}
+
+	vschema := BuildVSchema(source, sqlparser.NewTestParser())
+	require.NotNil(t, vschema)
+
+	// Check table is global and points to the correct keyspace
+	mustRouteGlobally := func(t *testing.T, tname, ksName string) {
+		t.Helper()
+		tbl, err := vschema.FindTable("", tname)
+		require.NoError(t, err)
+		require.Equalf(t, ksName, tbl.Keyspace.Name, "table %s should be in keyspace %s", tname, ksName)
+	}
+
+	mustNotRouteGlobally := func(t *testing.T, tname string) {
+		t.Helper()
+		_, err := vschema.FindTable("", tname)
+		require.Error(t, err)
+	}
+
+	// Verify the global tables
+	ks := vschema.Keyspaces["sharded1"]
+	require.EqualValues(t, vschema.globalTables, map[string]*Table{
+		"table5":   ks.Tables["table5"],
+		"scommon1": ks.Tables["scommon1"],
+		"scommon2": ks.Tables["scommon2"],
+	})
+	mustRouteGlobally(t, "table5", "sharded1")
+	mustRouteGlobally(t, "scommon1", "sharded1")
+	mustRouteGlobally(t, "scommon2", "sharded1")
+
+	// Add unsharded keyspaces to SrvVSchema and build VSchema
+	var err error
+	source.Keyspaces["unsharded1"] = unsharded1
+	source.Keyspaces["unsharded2"] = unsharded2
+	vschema.Keyspaces["unsharded1"], err = BuildKeyspace(unsharded1, sqlparser.NewTestParser())
+	require.NoError(t, err)
+	vschema.Keyspaces["unsharded2"], err = BuildKeyspace(unsharded2, sqlparser.NewTestParser())
+	require.NoError(t, err)
+
+	// Verify the global tables don't change
+	mustRouteGlobally(t, "table5", "sharded1")
+	mustRouteGlobally(t, "scommon1", "sharded1")
+	mustRouteGlobally(t, "scommon2", "sharded1")
+
+	// Add additional global tables and then verify that the unsharded global tables are added
+	AddAdditionalGlobalTables(source, vschema)
+
+	mustRouteGlobally(t, "table1", "unsharded1")
+	mustRouteGlobally(t, "table2", "unsharded1")
+
+	mustRouteGlobally(t, "table3", "unsharded2")
+	mustRouteGlobally(t, "table4", "unsharded2")
+	mustNotRouteGlobally(t, "ucommon3")
+
+	mustRouteGlobally(t, "scommon1", "sharded1")
+	mustRouteGlobally(t, "scommon2", "sharded1")
+	mustRouteGlobally(t, "table5", "sharded1")
+
+	mustNotRouteGlobally(t, "table6")
+	mustNotRouteGlobally(t, "scommon3")
+}
+
+func TestVSchemaRoutingRules(t *testing.T) {
+	input := vschemapb.SrvVSchema{
+		RoutingRules: &vschemapb.RoutingRules{
+			Rules: []*vschemapb.RoutingRule{{
+				FromTable: "rt1",
+				ToTables:  []string{"ks1.t1", "ks2.t2"},
+			}, {
+				FromTable: "rt2",
+				ToTables:  []string{"ks2.t2"},
+			}, {
+				FromTable: "escaped",
+				ToTables:  []string{"`ks2`.`t2`"},
+			}, {
+				FromTable: "dup",
+				ToTables:  []string{"ks1.t1"},
+			}, {
+				FromTable: "dup",
+				ToTables:  []string{"ks1.t1"},
+			}, {
+				FromTable: "badname",
+				ToTables:  []string{"t1.t2.t3"},
+			}, {
+				FromTable: "unqualified",
+				ToTables:  []string{"t1"},
+			}, {
+				FromTable: "badkeyspace",
+				ToTables:  []string{"ks3.t1"},
+			}, {
+				FromTable: "notfound",
+				ToTables:  []string{"ks1.t2"},
+			}},
+		},
+		Keyspaces: map[string]*vschemapb.Keyspace{
+			"ks1": {
+				Sharded:        true,
+				ForeignKeyMode: vschemapb.Keyspace_unmanaged,
+				Vindexes: map[string]*vschemapb.Vindex{
+					"stfu1": {
+						Type: "stfu",
+					},
+				},
+				Tables: map[string]*vschemapb.Table{
+					"t1": {
+						ColumnVindexes: []*vschemapb.ColumnVindex{
+							{
+								Column: "c1",
+								Name:   "stfu1",
+							},
+						},
+					},
+				},
+			},
+			"ks2": {
+				ForeignKeyMode: vschemapb.Keyspace_managed,
+				Tables: map[string]*vschemapb.Table{
+					"t2": {},
+				},
+			},
+		},
+	}
+	got := BuildVSchema(&input, sqlparser.NewTestParser())
+	ks1 := &Keyspace{
+		Name:    "ks1",
+		Sharded: true,
+	}
+	ks2 := &Keyspace{
+		Name: "ks2",
+	}
+	vindex1 := &stFU{
+		name: "stfu1",
+	}
+	t1 := &Table{
+		Name:     sqlparser.NewIdentifierCS("t1"),
+		Keyspace: ks1,
+		ColumnVindexes: []*ColumnVindex{{
+			Columns:  []sqlparser.IdentifierCI{sqlparser.NewIdentifierCI("c1")},
+			Type:     "stfu",
+			Name:     "stfu1",
+			Vindex:   vindex1,
+			isUnique: vindex1.IsUnique(),
+			cost:     vindex1.Cost(),
+		}},
+	}
+	t1.Ordered = []*ColumnVindex{
+		t1.ColumnVindexes[0],
+	}
+	t2 := &Table{
+		Name:     sqlparser.NewIdentifierCS("t2"),
+		Keyspace: ks2,
+	}
+	want := &VSchema{
+		MirrorRules: map[string]*MirrorRule{},
+		RoutingRules: map[string]*RoutingRule{
+			"rt1": {
+				Error: errors.New("table rt1 has more than one target: [ks1.t1 ks2.t2]"),
+			},
+			"rt2": {
+				Tables: []*Table{t2},
+			},
+			"escaped": {
+				Tables: []*Table{t2},
+			},
+			"dup": {
+				Error: errors.New("duplicate rule for entry dup"),
+			},
+			"badname": {
+				Error: errors.New("invalid table name: 't1.t2.t3', it must be of the qualified form <keyspace_name>.<table_name> (dots are not allowed in either name)"),
+			},
+			"unqualified": {
+				Error: errors.New("invalid table name: 't1', it must be of the qualified form <keyspace_name>.<table_name> (dots are not allowed in either name)"),
+			},
+			"badkeyspace": {
+				Error: errors.New("VT05003: unknown database 'ks3' in vschema"),
+			},
+			"notfound": {
+				Error: errors.New("table t2 not found"),
+			},
+		},
+		globalTables: map[string]*Table{
+			"t1": t1,
+			"t2": t2,
+		},
+		uniqueVindexes: map[string]Vindex{
+			"stfu1": vindex1,
+		},
+		Keyspaces: map[string]*KeyspaceSchema{
+			"ks1": {
+				Keyspace:       ks1,
+				ForeignKeyMode: vschemapb.Keyspace_unmanaged,
+				Tables: map[string]*Table{
+					"t1": t1,
+				},
+				Vindexes: map[string]Vindex{
+					"stfu1": vindex1,
+				},
+			},
+			"ks2": {
+				ForeignKeyMode: vschemapb.Keyspace_managed,
+				Keyspace:       ks2,
+				Tables: map[string]*Table{
+					"t2": t2,
+				},
+				Vindexes: map[string]Vindex{},
+			},
+		},
+	}
+	gotb, _ := json.MarshalIndent(got, "", "  ")
+	wantb, _ := json.MarshalIndent(want, "", "  ")
+	assert.Equal(t, string(wantb), string(gotb), string(gotb))
+}
diff --git a/go/vt/vtgate/vindexes/vschema_test.go b/go/vt/vtgate/vindexes/vschema_test.go
index 25f8e135698..f15e4770e36 100644
--- a/go/vt/vtgate/vindexes/vschema_test.go
+++ b/go/vt/vtgate/vindexes/vschema_test.go
@@ -747,157 +747,6 @@ func TestShardedVSchemaOwnerInfo(t *testing.T) {
 	}
 }
 
-func TestVSchemaRoutingRules(t *testing.T) {
-	input := vschemapb.SrvVSchema{
-		RoutingRules: &vschemapb.RoutingRules{
-			Rules: []*vschemapb.RoutingRule{{
-				FromTable: "rt1",
-				ToTables:  []string{"ks1.t1", "ks2.t2"},
-			}, {
-				FromTable: "rt2",
-				ToTables:  []string{"ks2.t2"},
-			}, {
-				FromTable: "escaped",
-				ToTables:  []string{"`ks2`.`t2`"},
-			}, {
-				FromTable: "dup",
-				ToTables:  []string{"ks1.t1"},
-			}, {
-				FromTable: "dup",
-				ToTables:  []string{"ks1.t1"},
-			}, {
-				FromTable: "badname",
-				ToTables:  []string{"t1.t2.t3"},
-			}, {
-				FromTable: "unqualified",
-				ToTables:  []string{"t1"},
-			}, {
-				FromTable: "badkeyspace",
-				ToTables:  []string{"ks3.t1"},
-			}, {
-				FromTable: "notfound",
-				ToTables:  []string{"ks1.t2"},
-			}},
-		},
-		Keyspaces: map[string]*vschemapb.Keyspace{
-			"ks1": {
-				Sharded:        true,
-				ForeignKeyMode: vschemapb.Keyspace_unmanaged,
-				Vindexes: map[string]*vschemapb.Vindex{
-					"stfu1": {
-						Type: "stfu",
-					},
-				},
-				Tables: map[string]*vschemapb.Table{
-					"t1": {
-						ColumnVindexes: []*vschemapb.ColumnVindex{
-							{
-								Column: "c1",
-								Name:   "stfu1",
-							},
-						},
-					},
-				},
-			},
-			"ks2": {
-				ForeignKeyMode: vschemapb.Keyspace_managed,
-				Tables: map[string]*vschemapb.Table{
-					"t2": {},
-				},
-			},
-		},
-	}
-	got := BuildVSchema(&input, sqlparser.NewTestParser())
-	ks1 := &Keyspace{
-		Name:    "ks1",
-		Sharded: true,
-	}
-	ks2 := &Keyspace{
-		Name: "ks2",
-	}
-	vindex1 := &stFU{
-		name: "stfu1",
-	}
-	t1 := &Table{
-		Name:     sqlparser.NewIdentifierCS("t1"),
-		Keyspace: ks1,
-		ColumnVindexes: []*ColumnVindex{{
-			Columns:  []sqlparser.IdentifierCI{sqlparser.NewIdentifierCI("c1")},
-			Type:     "stfu",
-			Name:     "stfu1",
-			Vindex:   vindex1,
-			isUnique: vindex1.IsUnique(),
-			cost:     vindex1.Cost(),
-		}},
-	}
-	t1.Ordered = []*ColumnVindex{
-		t1.ColumnVindexes[0],
-	}
-	t2 := &Table{
-		Name:     sqlparser.NewIdentifierCS("t2"),
-		Keyspace: ks2,
-	}
-	want := &VSchema{
-		MirrorRules: map[string]*MirrorRule{},
-		RoutingRules: map[string]*RoutingRule{
-			"rt1": {
-				Error: errors.New("table rt1 has more than one target: [ks1.t1 ks2.t2]"),
-			},
-			"rt2": {
-				Tables: []*Table{t2},
-			},
-			"escaped": {
-				Tables: []*Table{t2},
-			},
-			"dup": {
-				Error: errors.New("duplicate rule for entry dup"),
-			},
-			"badname": {
-				Error: errors.New("invalid table name: 't1.t2.t3', it must be of the qualified form <keyspace_name>.<table_name> (dots are not allowed in either name)"),
-			},
-			"unqualified": {
-				Error: errors.New("invalid table name: 't1', it must be of the qualified form <keyspace_name>.<table_name> (dots are not allowed in either name)"),
-			},
-			"badkeyspace": {
-				Error: errors.New("VT05003: unknown database 'ks3' in vschema"),
-			},
-			"notfound": {
-				Error: errors.New("table t2 not found"),
-			},
-		},
-		globalTables: map[string]*Table{
-			"t1": t1,
-			"t2": t2,
-		},
-		uniqueVindexes: map[string]Vindex{
-			"stfu1": vindex1,
-		},
-		Keyspaces: map[string]*KeyspaceSchema{
-			"ks1": {
-				Keyspace:       ks1,
-				ForeignKeyMode: vschemapb.Keyspace_unmanaged,
-				Tables: map[string]*Table{
-					"t1": t1,
-				},
-				Vindexes: map[string]Vindex{
-					"stfu1": vindex1,
-				},
-			},
-			"ks2": {
-				ForeignKeyMode: vschemapb.Keyspace_managed,
-				Keyspace:       ks2,
-				Tables: map[string]*Table{
-					"t2": t2,
-				},
-				Vindexes: map[string]Vindex{},
-			},
-		},
-	}
-	gotb, _ := json.MarshalIndent(got, "", "  ")
-	wantb, _ := json.MarshalIndent(want, "", "  ")
-	assert.Equal(t, string(wantb), string(gotb), string(gotb))
-}
-
 func TestVSchemaMirrorRules(t *testing.T) {
 	input := vschemapb.SrvVSchema{
 		MirrorRules: &vschemapb.MirrorRules{
diff --git a/go/vt/vtgate/vschema_manager.go b/go/vt/vtgate/vschema_manager.go
index 9c0aaf1d186..290971c45ed 100644
--- a/go/vt/vtgate/vschema_manager.go
+++ b/go/vt/vtgate/vschema_manager.go
@@ -197,7 +197,7 @@ func (vm *VSchemaManager) buildAndEnhanceVSchema(v *vschemapb.SrvVSchema) *vinde
 		// Add tables from schema tracking into globally routable tables, if they are not already present.
 		// We need to skip if already present, to handle the case where MoveTables has switched traffic
 		// and removed the source vschema but not from the source database because user asked to --keep-data
-		vindexes.BuildGlobalTables(v, vschema, true)
+		vindexes.AddAdditionalGlobalTables(v, vschema)
 	}
 	return vschema
 }