diff --git a/.eslintrc.json b/.eslintrc.json
index 710c3bd6..39773f7d 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -11,7 +11,8 @@
   "parser": "@typescript-eslint/parser",
   "parserOptions": {
     "ecmaVersion": "latest",
-    "sourceType": "module"
+    "sourceType": "module",
+    "project": ["./tsconfig.base.json"]
   },
   "plugins": ["@typescript-eslint"],
   "rules": {
@@ -23,6 +24,7 @@
     "@typescript-eslint/ban-ts-comment": "off",
     "@typescript-eslint/no-empty-interface": "off",
     "@typescript-eslint/no-empty-function": "off",
-    "@typescript-eslint/no-this-alias": "off"
+    "@typescript-eslint/no-this-alias": "off",
+    "@typescript-eslint/no-floating-promises": "warn"
   }
 }
diff --git a/package-lock.json b/package-lock.json
index 146fd0e7..56d6ebd7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -54,7 +54,7 @@
         "@angularclass/hmr": "^3.0.0",
         "@babel/plugin-proposal-decorators": "^7.18.10",
         "@ngtools/webpack": "^13.3.9",
-        "@playwright/test": "^1.39.0",
+        "@playwright/test": "^1.43.1",
         "@types/aws-param-store": "^2.1.2",
         "@types/browser-update": "^3.3.0",
         "@types/compression": "^1.7.2",
@@ -4302,12 +4302,12 @@
       }
     },
     "node_modules/@playwright/test": {
-      "version": "1.39.0",
-      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.39.0.tgz",
-      "integrity": "sha512-3u1iFqgzl7zr004bGPYiN/5EZpRUSFddQBra8Rqll5N0/vfpqlP9I9EXqAoGacuAbX6c9Ulg/Cjqglp5VkK6UQ==",
+      "version": "1.43.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.43.1.tgz",
+      "integrity": "sha512-HgtQzFgNEEo4TE22K/X7sYTYNqEMMTZmFS8kTq6m8hXj+m1D8TgwgIbumHddJa9h4yl4GkKb8/bgAl2+g7eDgA==",
       "dev": true,
       "dependencies": {
-        "playwright": "1.39.0"
+        "playwright": "1.43.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -16942,12 +16942,12 @@
       }
     },
     "node_modules/playwright": {
-      "version": "1.39.0",
-      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.39.0.tgz",
-      "integrity": "sha512-naE5QT11uC/Oiq0BwZ50gDmy8c8WLPRTEWuSSFVG2egBka/1qMoSqYQcROMT9zLwJ86oPofcTH2jBY/5wWOgIw==",
+      "version": "1.43.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.43.1.tgz",
+      "integrity": "sha512-V7SoH0ai2kNt1Md9E3Gwas5B9m8KR2GVvwZnAI6Pg0m3sh7UvgiYhRrhsziCmqMJNouPckiOhk8T+9bSAK0VIA==",
       "dev": true,
       "dependencies": {
-        "playwright-core": "1.39.0"
+        "playwright-core": "1.43.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -16960,9 +16960,9 @@
       }
     },
     "node_modules/playwright-core": {
-      "version": "1.39.0",
-      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.39.0.tgz",
-      "integrity": "sha512-+k4pdZgs1qiM+OUkSjx96YiKsXsmb59evFoqv8SKO067qBA+Z2s/dCzJij/ZhdQcs2zlTAgRKfeiiLm8PQ2qvw==",
+      "version": "1.43.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.43.1.tgz",
+      "integrity": "sha512-EI36Mto2Vrx6VF7rm708qSnesVQKbxEWvPrfA1IPY6HgczBplDx7ENtx+K2n4kJ41sLLkuGfmb0ZLSSXlDhqPg==",
       "dev": true,
       "bin": {
         "playwright-core": "cli.js"
@@ -25601,12 +25601,12 @@
       }
     },
     "@playwright/test": {
-      "version": "1.39.0",
-      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.39.0.tgz",
-      "integrity": "sha512-3u1iFqgzl7zr004bGPYiN/5EZpRUSFddQBra8Rqll5N0/vfpqlP9I9EXqAoGacuAbX6c9Ulg/Cjqglp5VkK6UQ==",
+      "version": "1.43.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.43.1.tgz",
+      "integrity": "sha512-HgtQzFgNEEo4TE22K/X7sYTYNqEMMTZmFS8kTq6m8hXj+m1D8TgwgIbumHddJa9h4yl4GkKb8/bgAl2+g7eDgA==",
       "dev": true,
       "requires": {
-        "playwright": "1.39.0"
+        "playwright": "1.43.1"
       }
     },
     "@popperjs/core": {
@@ -35507,19 +35507,19 @@
       }
     },
     "playwright": {
-      "version": "1.39.0",
-      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.39.0.tgz",
-      "integrity": "sha512-naE5QT11uC/Oiq0BwZ50gDmy8c8WLPRTEWuSSFVG2egBka/1qMoSqYQcROMT9zLwJ86oPofcTH2jBY/5wWOgIw==",
+      "version": "1.43.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.43.1.tgz",
+      "integrity": "sha512-V7SoH0ai2kNt1Md9E3Gwas5B9m8KR2GVvwZnAI6Pg0m3sh7UvgiYhRrhsziCmqMJNouPckiOhk8T+9bSAK0VIA==",
       "dev": true,
       "requires": {
         "fsevents": "2.3.2",
-        "playwright-core": "1.39.0"
+        "playwright-core": "1.43.1"
       }
     },
     "playwright-core": {
-      "version": "1.39.0",
-      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.39.0.tgz",
-      "integrity": "sha512-+k4pdZgs1qiM+OUkSjx96YiKsXsmb59evFoqv8SKO067qBA+Z2s/dCzJij/ZhdQcs2zlTAgRKfeiiLm8PQ2qvw==",
+      "version": "1.43.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.43.1.tgz",
+      "integrity": "sha512-EI36Mto2Vrx6VF7rm708qSnesVQKbxEWvPrfA1IPY6HgczBplDx7ENtx+K2n4kJ41sLLkuGfmb0ZLSSXlDhqPg==",
       "dev": true
     },
     "portfinder": {
diff --git a/package.json b/package.json
index 630d4b0d..a92ebd8d 100644
--- a/package.json
+++ b/package.json
@@ -39,7 +39,8 @@
     "mongo:start:windows": "sh ./scripts/start-mongo.sh 'C:\\data\\db'",
     "data:local": "npm run clean:data && sh ./scripts/get-data-local.sh",
     "e2e": "playwright test --trace on",
-    "e2e:ui": "playwright test --ui"
+    "e2e:ui": "playwright test --ui",
+    "e2e:update": "npm install -D @playwright/test@latest; npx playwright install --with-deps; npx playwright --version"
   },
   "pre-commit": [
     "test"
@@ -94,7 +95,7 @@
     "@angularclass/hmr": "^3.0.0",
     "@babel/plugin-proposal-decorators": "^7.18.10",
     "@ngtools/webpack": "^13.3.9",
-    "@playwright/test": "^1.39.0",
+    "@playwright/test": "^1.43.1",
     "@types/aws-param-store": "^2.1.2",
     "@types/browser-update": "^3.3.0",
     "@types/compression": "^1.7.2",
diff --git a/src/app/core/components/footer/footer.component.spec.ts b/src/app/core/components/footer/footer.component.spec.ts
index 9154ab96..6fc4041c 100644
--- a/src/app/core/components/footer/footer.component.spec.ts
+++ b/src/app/core/components/footer/footer.component.spec.ts
@@ -72,6 +72,8 @@ describe('Component: Footer', () => {
     const link = element.querySelector('.footer-logo a') as HTMLElement;
     expect(link).toBeTruthy();
 
+    // https://github.com/angular/angular/issues/45202
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     router.navigate(['/about']);
     tick();
     expect(location.path()).toBe('/about');
diff --git a/src/app/core/components/header/header.component.spec.ts b/src/app/core/components/header/header.component.spec.ts
index c972f8ca..c77798b7 100644
--- a/src/app/core/components/header/header.component.spec.ts
+++ b/src/app/core/components/header/header.component.spec.ts
@@ -69,6 +69,8 @@ describe('Component: Header', () => {
     const link = element.querySelector('.header-logo a') as HTMLElement;
     expect(link).toBeTruthy();
 
+    // https://github.com/angular/angular/issues/45202
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     router.navigate(['/nominated-targets']);
     tick();
     expect(location.path()).toBe('/nominated-targets');
diff --git a/src/app/features/charts/components/median-barchart/median-barchart.component.spec.ts b/src/app/features/charts/components/median-barchart/median-barchart.component.spec.ts
index 6b73bc01..6e3f835f 100644
--- a/src/app/features/charts/components/median-barchart/median-barchart.component.spec.ts
+++ b/src/app/features/charts/components/median-barchart/median-barchart.component.spec.ts
@@ -54,8 +54,8 @@ describe('Component: BarChart - Median', () => {
   let component: MedianBarChartComponent;
   let element: HTMLElement;
 
-  beforeEach(waitForAsync(() => {
-    TestBed.configureTestingModule({
+  beforeEach(waitForAsync(async () => {
+    await TestBed.configureTestingModule({
       declarations: [MedianBarChartComponent],
       imports: [RouterTestingModule],
       providers: [HelperService],
diff --git a/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.html b/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.html
index b41680f5..42772416 100644
--- a/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.html
+++ b/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.html
@@ -403,6 +403,7 @@ <h1 class="gct-heading h2">Gene Comparison Tool</h1>
                 <div *ngIf="genesTable.filteredValue?.length">
                   <button
                     class="pin-all-button"
+                    [disabled]="getPinDisabledStatus()"
                     [ngClass]="{
                       disabled: getPinDisabledStatus()
                     }"
@@ -471,6 +472,7 @@ <h1 class="gct-heading h2">Gene Comparison Tool</h1>
                       <div>
                         <button
                           (click)="onPinGeneClick(gene)"
+                          [disabled]="getPinDisabledStatus()"
                           [ngClass]="{
                             disabled: getPinDisabledStatus()
                           }"
diff --git a/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.spec.ts b/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.spec.ts
index c754110b..80f9ffb4 100644
--- a/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.spec.ts
+++ b/src/app/features/genes/components/gene-comparison-tool/gene-comparison-tool.component.spec.ts
@@ -48,8 +48,8 @@ describe('Component: GeneComparisonToolComponent', () => {
   let element: HTMLElement;
   let route: ActivatedRoute;
 
-  beforeEach(fakeAsync(() => {
-    TestBed.configureTestingModule({
+  beforeEach(fakeAsync(async () => {
+    await TestBed.configureTestingModule({
       declarations: [
         GeneComparisonToolComponent,
         GeneComparisonToolDetailsPanelComponent,
diff --git a/src/app/features/genes/components/gene-details/gene-details.component.ts b/src/app/features/genes/components/gene-details/gene-details.component.ts
index a37476d9..c9c204d6 100644
--- a/src/app/features/genes/components/gene-details/gene-details.component.ts
+++ b/src/app/features/genes/components/gene-details/gene-details.component.ts
@@ -138,6 +138,8 @@ export class GeneDetailsComponent implements OnInit, AfterViewInit {
           .subscribe((gene) => {
             if (!gene) {
               this.helperService.setLoading(false);
+              // https://github.com/angular/angular/issues/45202
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
               this.router.navigateByUrl('/404-not-found', { skipLocationChange: true });
             } else {
               this.gene = gene;
diff --git a/src/app/features/genes/components/gene-network/gene-network.component.ts b/src/app/features/genes/components/gene-network/gene-network.component.ts
index f6d7c0d9..91af46ed 100644
--- a/src/app/features/genes/components/gene-network/gene-network.component.ts
+++ b/src/app/features/genes/components/gene-network/gene-network.component.ts
@@ -91,6 +91,8 @@ export class GeneNetworkComponent implements OnInit {
   }
 
   navigateToSimilarGenes() {
+    // https://github.com/angular/angular/issues/45202
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     this.router.navigate([
       '/genes/' + this._gene?.ensembl_gene_id + '/similar',
     ]);
diff --git a/src/app/features/genes/components/gene-search/gene-search.component.ts b/src/app/features/genes/components/gene-search/gene-search.component.ts
index 8a8e0fd0..f7a02316 100644
--- a/src/app/features/genes/components/gene-search/gene-search.component.ts
+++ b/src/app/features/genes/components/gene-search/gene-search.component.ts
@@ -157,6 +157,8 @@ export class GeneSearchComponent extends Unsub implements AfterViewInit {
     this.results = [];
     this.showGeneResults = false;
     this.searchNavigated.emit();
+    // https://github.com/angular/angular/issues/45202
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     this.router.navigate(['/genes/' + id]);
   }
 
diff --git a/src/app/features/genes/components/gene-similar/gene-similar.component.ts b/src/app/features/genes/components/gene-similar/gene-similar.component.ts
index a8be4ea3..1d475610 100644
--- a/src/app/features/genes/components/gene-similar/gene-similar.component.ts
+++ b/src/app/features/genes/components/gene-similar/gene-similar.component.ts
@@ -72,6 +72,8 @@ export class GeneSimilarComponent implements OnInit {
           .subscribe((gene: Gene | null) => {
             if (!gene) {
               this.helperService.setLoading(false);
+              // https://github.com/angular/angular/issues/45202
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
               this.router.navigateByUrl('/404-not-found', { skipLocationChange: true });
             } else {
               this.gene = gene;
@@ -144,6 +146,8 @@ export class GeneSimilarComponent implements OnInit {
   navigateToGeneComparisonTool() {
     const ids: string[] = this.genes.map((g: Gene) => g.ensembl_gene_id);
     this.helperService.setGCTSelection(ids);
+    // https://github.com/angular/angular/issues/45202
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     this.router.navigate(['/genes/comparison']);
   }
 }
diff --git a/src/app/features/genes/components/gene-table/gene-table.component.ts b/src/app/features/genes/components/gene-table/gene-table.component.ts
index beacff8b..fc80a076 100644
--- a/src/app/features/genes/components/gene-table/gene-table.component.ts
+++ b/src/app/features/genes/components/gene-table/gene-table.component.ts
@@ -139,6 +139,8 @@ export class GeneTableComponent implements OnInit {
   }
 
   navigateToGene(gene: any) {
+    // https://github.com/angular/angular/issues/45202
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     this.router.navigate(['/genes/' + gene.ensembl_gene_id]);
   }
 
@@ -174,12 +176,16 @@ export class GeneTableComponent implements OnInit {
 
   navigateToGeneComparisonTool() {
     if (typeof this.gctLink === 'object') {
+      // https://github.com/angular/angular/issues/45202
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
       this.router.navigate(['/genes/comparison'], {
         queryParams: this.gctLink,
       });
     } else {
       const ids: string[] = this._genes.map((g: Gene) => g.ensembl_gene_id);
       this.helperService.setGCTSelection(ids);
+      // https://github.com/angular/angular/issues/45202
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
       this.router.navigate(['/genes/comparison']);
     }
   }
diff --git a/tests/gene-comparison-tool-pinning-cache.spec.ts b/tests/gene-comparison-tool-pinning-cache.spec.ts
new file mode 100644
index 00000000..6fc0b530
--- /dev/null
+++ b/tests/gene-comparison-tool-pinning-cache.spec.ts
@@ -0,0 +1,416 @@
+import { expect, test } from '@playwright/test';
+import {
+  GCT_CATEGORIES,
+  GCT_PROTEIN_SUBCATEGORIES,
+  GCT_RNA_SUBCATEGORIES,
+  URL_GCT,
+  URL_GCT_PROTEIN_TMT,
+} from './helpers/constants';
+import {
+  gene2WithMultipleProteinsTMT,
+  geneWithMultipleProteinsTMT,
+} from './helpers/data';
+import {
+  changeGctCategory,
+  changeGctSubcategory,
+  expectGctPageLoaded,
+} from './helpers/gct';
+import {
+  confirmPinnedItemsByGeneName,
+  confirmPinnedItemsByItemName,
+  confirmPinnedItemsCount,
+  confirmPinnedProteins,
+  expectPinnedGenesCountText,
+  expectPinnedProteinsCountText,
+  pinAllItemsViaSearchByGene,
+  pinGeneViaSearch,
+  pinMultipleGenesViaSearch,
+} from './helpers/gct-pinning';
+
+test.describe('GCT: Caching pinned genes', () => {
+  test('Pinned genes are maintained when switching between RNA subcategories', async ({
+    page,
+  }) => {
+    const genes = ['CYB561A3', 'MANBAL', 'PLEC', 'GFAP'];
+    const nGenes = genes.length;
+
+    await page.goto(URL_GCT);
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await pinMultipleGenesViaSearch(page, genes);
+
+    await test.step('confirm # genes pinned on AD subcategory page', async () => {
+      await expectPinnedGenesCountText(page, nGenes);
+      await confirmPinnedItemsCount(page, nGenes);
+    });
+
+    await changeGctSubcategory(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD,
+      GCT_RNA_SUBCATEGORIES.AD_AOD
+    );
+
+    await changeGctSubcategory(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD_AOD,
+      GCT_RNA_SUBCATEGORIES.AD_SEX_F
+    );
+
+    await changeGctSubcategory(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD_SEX_F,
+      GCT_RNA_SUBCATEGORIES.AD_SEX_M
+    );
+
+    // back to original subcategory
+    await changeGctSubcategory(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD_SEX_M,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await test.step('confirm same genes pinned on AD subcategory page', async () => {
+      await expectPinnedGenesCountText(page, nGenes);
+      await confirmPinnedItemsCount(page, nGenes);
+      await confirmPinnedItemsByItemName(page, genes);
+    });
+  });
+
+  test('Pinned genes are maintained when switching categories: RNA -> Protein -> RNA', async ({
+    page,
+  }) => {
+    const genes = ['CYB561A3', 'MANBAL', 'PLEC', 'GFAP'];
+    const nGenes = genes.length;
+
+    await page.goto(URL_GCT);
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await pinMultipleGenesViaSearch(page, genes);
+
+    await test.step('confirm # genes pinned on RNA page', async () => {
+      await expectPinnedGenesCountText(page, nGenes);
+      await confirmPinnedItemsCount(page, nGenes);
+    });
+
+    await changeGctCategory(page, GCT_CATEGORIES.RNA, GCT_CATEGORIES.PROTEIN);
+
+    await changeGctSubcategory(
+      page,
+      GCT_CATEGORIES.PROTEIN,
+      GCT_PROTEIN_SUBCATEGORIES.SRM,
+      GCT_PROTEIN_SUBCATEGORIES.TMT
+    );
+
+    await changeGctSubcategory(
+      page,
+      GCT_CATEGORIES.PROTEIN,
+      GCT_PROTEIN_SUBCATEGORIES.TMT,
+      GCT_PROTEIN_SUBCATEGORIES.LFQ
+    );
+
+    // back to original category
+    await changeGctCategory(page, GCT_CATEGORIES.PROTEIN, GCT_CATEGORIES.RNA);
+
+    await test.step('confirm same genes pinned on RNA page', async () => {
+      await expectPinnedGenesCountText(page, nGenes);
+      await confirmPinnedItemsCount(page, nGenes);
+      await confirmPinnedItemsByItemName(page, genes);
+    });
+  });
+
+  test(
+    'Pinned proteins are maintained when switching between Protein subcategories',
+    async ({ page }) => {
+      const gene1 = geneWithMultipleProteinsTMT.name;
+      const gene2 = gene2WithMultipleProteinsTMT.name;
+      const genes = [gene1, gene2];
+      const nGenes = genes.length;
+
+      const proteins1 = geneWithMultipleProteinsTMT.uniProtIds;
+      const proteins2 = gene2WithMultipleProteinsTMT.uniProtIds;
+      const nProteins = proteins1.length + proteins2.length;
+
+      await page.goto(URL_GCT_PROTEIN_TMT);
+      await expectGctPageLoaded(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      for (const gene of genes) {
+        await pinAllItemsViaSearchByGene(page, gene);
+      }
+
+      await test.step('confirm # genes and proteins pinned on Protein page', async () => {
+        await expectPinnedGenesCountText(page, nGenes);
+        await expectPinnedProteinsCountText(page, nProteins);
+        await confirmPinnedItemsCount(page, nProteins);
+      });
+
+      await changeGctSubcategory(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT,
+        GCT_PROTEIN_SUBCATEGORIES.SRM
+      );
+
+      await changeGctSubcategory(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.SRM,
+        GCT_PROTEIN_SUBCATEGORIES.LFQ
+      );
+
+      // back to original subcategory
+      await changeGctSubcategory(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.LFQ,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      await test.step('confirm same genes and proteins pinned on Protein page', async () => {
+        await expectPinnedGenesCountText(page, nGenes);
+        await expectPinnedProteinsCountText(page, nProteins);
+        await confirmPinnedItemsCount(page, nProteins);
+
+        await confirmPinnedProteins(page, gene1, proteins1);
+        await confirmPinnedProteins(page, gene2, proteins2);
+      });
+    }
+  );
+
+  test(
+    'Pinned proteins are maintained when switching categories: Protein -> RNA -> Protein',
+    async ({ page }) => {
+      const gene1 = geneWithMultipleProteinsTMT.name;
+      const gene2 = gene2WithMultipleProteinsTMT.name;
+      const genes = [gene1, gene2];
+      const nGenes = genes.length;
+
+      const proteins1 = geneWithMultipleProteinsTMT.uniProtIds;
+      const proteins2 = gene2WithMultipleProteinsTMT.uniProtIds;
+      const nProteins = proteins1.length + proteins2.length;
+
+      await page.goto(URL_GCT_PROTEIN_TMT);
+      await expectGctPageLoaded(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      for (const gene of genes) {
+        await pinAllItemsViaSearchByGene(page, gene);
+      }
+
+      await test.step('confirm # genes and proteins pinned on Protein page', async () => {
+        await expectPinnedGenesCountText(page, nGenes);
+        await expectPinnedProteinsCountText(page, nProteins);
+        await confirmPinnedItemsCount(page, nProteins);
+      });
+
+      await changeGctCategory(page, GCT_CATEGORIES.PROTEIN, GCT_CATEGORIES.RNA);
+
+      await changeGctSubcategory(
+        page,
+        GCT_CATEGORIES.RNA,
+        GCT_RNA_SUBCATEGORIES.AD,
+        GCT_RNA_SUBCATEGORIES.AD_AOD
+      );
+
+      // back to original category
+      await changeGctCategory(page, GCT_CATEGORIES.RNA, GCT_CATEGORIES.PROTEIN);
+
+      // back to original subcategory
+      await changeGctSubcategory(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.SRM,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      await test.step('confirm same genes and proteins pinned on Protein page', async () => {
+        await expectPinnedGenesCountText(page, nGenes);
+        await expectPinnedProteinsCountText(page, nProteins);
+
+        await confirmPinnedItemsCount(page, nProteins);
+        await confirmPinnedProteins(page, gene1, proteins1);
+        await confirmPinnedProteins(page, gene2, proteins2);
+      });
+    }
+  );
+
+  test(
+    'Last pinned genes are maintained even if proteins were pinned initially',
+    async ({ page }) => {
+      const rnaCategoryGene = geneWithMultipleProteinsTMT.name;
+      const rnaCategoryProteins = geneWithMultipleProteinsTMT.uniProtIds;
+      const proteinCategoryGene = gene2WithMultipleProteinsTMT.name;
+
+      await test.step('pin proteins in Protein category', async () => {
+        await page.goto(URL_GCT_PROTEIN_TMT);
+        await expectGctPageLoaded(
+          page,
+          GCT_CATEGORIES.PROTEIN,
+          GCT_PROTEIN_SUBCATEGORIES.TMT
+        );
+
+        await pinAllItemsViaSearchByGene(page, proteinCategoryGene);
+      });
+
+      await test.step('pin genes in RNA category', async () => {
+        await changeGctCategory(
+          page,
+          GCT_CATEGORIES.PROTEIN,
+          GCT_CATEGORIES.RNA
+        );
+
+        await test.step('clear all items', async () => {
+          await page.getByRole('button', { name: 'Clear All' }).click();
+          await expect(page.getByText(/Pinned Genes/i)).not.toBeVisible();
+        });
+
+        await pinGeneViaSearch(page, rnaCategoryGene);
+
+        await test.step('confirm pinned gene', async () => {
+          await expectPinnedGenesCountText(page, 1);
+          await confirmPinnedItemsByGeneName(page, rnaCategoryGene, 1);
+        });
+      });
+
+      await test.step('Protein category pins have changed', async () => {
+        await changeGctCategory(
+          page,
+          GCT_CATEGORIES.RNA,
+          GCT_CATEGORIES.PROTEIN
+        );
+        await changeGctSubcategory(
+          page,
+          GCT_CATEGORIES.PROTEIN,
+          GCT_PROTEIN_SUBCATEGORIES.SRM,
+          GCT_PROTEIN_SUBCATEGORIES.TMT
+        );
+        await expectPinnedGenesCountText(page, 1);
+        await expectPinnedProteinsCountText(page, rnaCategoryProteins.length);
+        await confirmPinnedProteins(page, rnaCategoryGene, rnaCategoryProteins);
+      });
+
+      await test.step('RNA category pins are maintained', async () => {
+        await changeGctCategory(
+          page,
+          GCT_CATEGORIES.PROTEIN,
+          GCT_CATEGORIES.RNA
+        );
+
+        await test.step('confirm pinned gene', async () => {
+          await expectPinnedGenesCountText(page, 1);
+          await confirmPinnedItemsByGeneName(page, rnaCategoryGene, 1);
+        });
+      });
+    }
+  );
+
+  test(
+    'Last pinned proteins are maintained even if genes were pinned initially',
+    async ({ page }) => {
+      const rnaCategoryGene = geneWithMultipleProteinsTMT.name;
+      const proteinCategoryGene = gene2WithMultipleProteinsTMT.name;
+      const proteinCategoryProteins = gene2WithMultipleProteinsTMT.uniProtIds;
+
+      await test.step('pin genes in RNA category', async () => {
+        await page.goto(URL_GCT);
+        await expectGctPageLoaded(
+          page,
+          GCT_CATEGORIES.RNA,
+          GCT_RNA_SUBCATEGORIES.AD
+        );
+
+        await pinGeneViaSearch(page, rnaCategoryGene);
+        await confirmPinnedItemsByGeneName(page, rnaCategoryGene, 1);
+      });
+
+      await test.step('pin proteins in Protein category', async () => {
+        await changeGctCategory(
+          page,
+          GCT_CATEGORIES.RNA,
+          GCT_CATEGORIES.PROTEIN
+        );
+        await changeGctSubcategory(
+          page,
+          GCT_CATEGORIES.PROTEIN,
+          GCT_PROTEIN_SUBCATEGORIES.SRM,
+          GCT_PROTEIN_SUBCATEGORIES.TMT
+        );
+
+        await test.step('clear all items', async () => {
+          await page.getByRole('button', { name: 'Clear All' }).click();
+          await expect(page.getByText(/Pinned Genes/i)).not.toBeVisible();
+        });
+
+        await pinAllItemsViaSearchByGene(page, proteinCategoryGene);
+
+        await test.step('confirm pinned items', async () => {
+          await expectPinnedGenesCountText(page, 1);
+          await expectPinnedProteinsCountText(
+            page,
+            proteinCategoryProteins.length
+          );
+          await confirmPinnedProteins(
+            page,
+            proteinCategoryGene,
+            proteinCategoryProteins
+          );
+        });
+      });
+
+      await test.step('RNA category pins have changed', async () => {
+        await changeGctCategory(
+          page,
+          GCT_CATEGORIES.PROTEIN,
+          GCT_CATEGORIES.RNA
+        );
+        await expectPinnedGenesCountText(page, 1);
+        await confirmPinnedItemsByGeneName(page, proteinCategoryGene, 1);
+      });
+
+      await test.step('Protein category pins are maintained', async () => {
+        await changeGctCategory(
+          page,
+          GCT_CATEGORIES.RNA,
+          GCT_CATEGORIES.PROTEIN
+        );
+        await changeGctSubcategory(
+          page,
+          GCT_CATEGORIES.PROTEIN,
+          GCT_PROTEIN_SUBCATEGORIES.SRM,
+          GCT_PROTEIN_SUBCATEGORIES.TMT
+        );
+
+        await test.step('confirm pinned items', async () => {
+          await expectPinnedGenesCountText(page, 1);
+          await expectPinnedProteinsCountText(
+            page,
+            proteinCategoryProteins.length
+          );
+          await confirmPinnedProteins(
+            page,
+            proteinCategoryGene,
+            proteinCategoryProteins
+          );
+        });
+      });
+    }
+  );
+});
diff --git a/tests/gene-comparison-tool-pinning-ui.spec.ts b/tests/gene-comparison-tool-pinning-ui.spec.ts
new file mode 100644
index 00000000..134b49d9
--- /dev/null
+++ b/tests/gene-comparison-tool-pinning-ui.spec.ts
@@ -0,0 +1,77 @@
+import { expect, test } from '@playwright/test';
+import { baseURL } from '../playwright.config';
+import {
+  GCT_CATEGORIES,
+  GCT_RNA_SUBCATEGORIES,
+  URL_GCT,
+} from './helpers/constants';
+import { expectGctPageLoaded } from './helpers/gct';
+import {
+  expectPinnedGenesCountText,
+  expectTooManyPinnedGenesToast,
+  formatPinnedGenesQueryParam,
+  getPinnedItemsFromUrl,
+  pinGeneViaSearch,
+} from './helpers/gct-pinning';
+
+test.describe('GCT: Pinning Genes via UI', () => {
+  test('one gene can be directly pinned', async ({ page }) => {
+    const geneName = 'GFAP';
+    const geneEnsemblId = 'ENSG00000131095';
+
+    await page.goto(URL_GCT);
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await pinGeneViaSearch(page, geneName);
+    await expectPinnedGenesCountText(page, 1);
+
+    await test.step('url has been updated', async () => {
+      const expectedUrl = `${baseURL}${URL_GCT}?${formatPinnedGenesQueryParam([
+        geneEnsemblId,
+      ])}`;
+      expect(page.url()).toEqual(expectedUrl);
+    });
+  });
+
+  test('only 50 genes are pinned when pinning all genes matched by a quick filter', async ({
+    page,
+  }) => {
+    await page.goto(URL_GCT);
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await test.step('apply a quick filter', async () => {
+      await page.getByRole('button', { name: 'Filter Genes' }).click();
+      await page.getByRole('button', { name: 'Quick Filters' }).click();
+      await page.getByText('All Nominated targets').click();
+
+      const filterPanel = page
+        .locator('.gct-filter-panel-pane-inner')
+        .filter({ hasText: 'Quick Filters' });
+      const filterCloseBtn = filterPanel.locator('.gct-filter-panel-close');
+      await filterCloseBtn.click();
+      await expect(filterPanel).not.toBeVisible();
+    });
+
+    await test.step('pin genes', async () => {
+      const pinAllBtn = page.getByRole('button', { name: 'Pin All' });
+      await pinAllBtn.click();
+      await expect(pinAllBtn).toBeDisabled();
+    });
+
+    await test.step('50 genes were pinned', async () => {
+      await expectTooManyPinnedGenesToast(page);
+      await expectPinnedGenesCountText(page, 50);
+
+      const genes = getPinnedItemsFromUrl(page.url());
+      expect(genes).toHaveLength(50);
+    });
+  });
+});
diff --git a/tests/gene-comparison-tool-pinning-url.spec.ts b/tests/gene-comparison-tool-pinning-url.spec.ts
new file mode 100644
index 00000000..82732fcc
--- /dev/null
+++ b/tests/gene-comparison-tool-pinning-url.spec.ts
@@ -0,0 +1,337 @@
+import { expect, test } from '@playwright/test';
+import {
+  GCT_CATEGORIES,
+  GCT_PROTEIN_SUBCATEGORIES,
+  GCT_RNA_SUBCATEGORIES,
+  URL_GCT,
+  URL_GCT_PROTEIN,
+  URL_GCT_PROTEIN_TMT,
+} from './helpers/constants';
+import {
+  fiftyGenes,
+  fiftyOneGenes,
+  fiftyProteinsToFiftyUniqueGenesTMT,
+  geneWithMultipleProteinsTMT,
+} from './helpers/data';
+import { expectGctPageLoaded, getGeneRowButtons } from './helpers/gct';
+import {
+  confirmPinnedItemsByGeneName,
+  confirmPinnedItemsCount,
+  expectPinnedGenesCountText,
+  expectPinnedProteinsCountText,
+  expectTooManyPinnedGenesToast,
+  formatPinnedGenesQueryParam,
+  getPinnedItemsFromUrl,
+} from './helpers/gct-pinning';
+
+test.describe('GCT: Pinning Genes from URL', () => {
+  test('when RNA url does not include pinned genes, no genes are pinned', async ({
+    page,
+  }) => {
+    await page.goto(URL_GCT);
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await expect(page.getByText('Pinned Genes')).not.toBeVisible();
+    await expect(page.getByText('All Genes')).not.toBeVisible();
+    await confirmPinnedItemsCount(page, 0);
+  });
+
+  test('when Protein url does not include pinned genes, no genes are pinned', async ({
+    page,
+  }) => {
+    await page.goto(URL_GCT_PROTEIN);
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.PROTEIN,
+      GCT_PROTEIN_SUBCATEGORIES.SRM
+    );
+
+    await expect(page.getByText('Pinned Genes')).not.toBeVisible();
+    await expect(page.getByText('All Genes')).not.toBeVisible();
+    await confirmPinnedItemsCount(page, 0);
+  });
+
+  test('when RNA url includes 50 pinned genes, all genes are pinned', async ({
+    page,
+  }) => {
+    const url = `${URL_GCT}?${formatPinnedGenesQueryParam(fiftyGenes)}`;
+    await page.goto(url);
+
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await test.step('confirm pinned all 50 genes', async () => {
+      await expect(page.getByText('All Genes')).toBeVisible();
+      await expectPinnedGenesCountText(page, 50);
+      await confirmPinnedItemsCount(page, 50);
+      await expect(page.getByRole('alert')).not.toBeVisible();
+    });
+
+    await test.step('confirm cannot pin other genes', async () => {
+      const btns = await getGeneRowButtons(page, 'PYGL');
+      await expect(btns.open).not.toBeDisabled();
+      await expect(btns.pin).toBeDisabled();
+    });
+  });
+
+  test('when RNA url includes >50 pinned genes, only 50 genes are pinned and toast is displayed', async ({
+    page,
+  }) => {
+    const url = `${URL_GCT}?${formatPinnedGenesQueryParam(fiftyOneGenes)}`;
+    await page.goto(url);
+
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await test.step('confirm only pinned 50 genes', async () => {
+      await expect(page.getByText('All Genes')).toBeVisible();
+      await expectPinnedGenesCountText(page, 50);
+      await confirmPinnedItemsCount(page, 50);
+      await expectTooManyPinnedGenesToast(page);
+    });
+
+    await test.step('confirm url dropped 51st gene', () => {
+      const genes = getPinnedItemsFromUrl(page.url());
+      expect(genes).toHaveLength(50);
+      expect(genes).toEqual(fiftyOneGenes.sort().slice(0, -1));
+    });
+  });
+
+  test('when RNA url includes invalid gene, that gene is dropped from the url', async ({
+    page,
+  }) => {
+    const validGeneId = geneWithMultipleProteinsTMT.ensemblId;
+    const url = `${URL_GCT}?${formatPinnedGenesQueryParam([
+      validGeneId,
+      'invalidGene',
+    ])}`;
+    await page.goto(url);
+
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await test.step('confirm toast not shown', async () => {
+      await expect(page.getByRole('alert')).not.toBeVisible();
+    });
+
+    await test.step('confirm only pinned 1 gene', async () => {
+      await expect(page.getByText('All Genes')).toBeVisible();
+      await expectPinnedGenesCountText(page, 1);
+      await confirmPinnedItemsCount(page, 1);
+    });
+
+    await test.step('confirm url dropped invalid gene', () => {
+      const genes = getPinnedItemsFromUrl(page.url());
+      expect(genes).toHaveLength(1);
+      expect(genes).toEqual([validGeneId]);
+    });
+  });
+
+  test.fail('when RNA url includes proteins, the related gene is pinned', {
+    annotation: {
+      type: 'fail', 
+      description: 'Since AG-1425, only genes will be pinned from RNA url'
+    }
+  },
+  async ({
+    page,
+  }) => {
+    const geneProteins = geneWithMultipleProteinsTMT.uniProtIds.map(
+      (uniProtId) => `${geneWithMultipleProteinsTMT.ensemblId}${uniProtId}`
+    );
+    const url = `${URL_GCT}?${formatPinnedGenesQueryParam(geneProteins)}`;
+    await page.goto(url);
+
+    await expectGctPageLoaded(
+      page,
+      GCT_CATEGORIES.RNA,
+      GCT_RNA_SUBCATEGORIES.AD
+    );
+
+    await confirmPinnedItemsByGeneName(
+      page,
+      geneWithMultipleProteinsTMT.name,
+      1
+    );
+    await expectPinnedGenesCountText(page, 1);
+    await confirmPinnedItemsCount(page, 1);
+  });
+
+  test.fail(
+    'when Protein url includes a gene, all related proteins are pinned', {
+      annotation: {
+        type: 'fail', 
+        description: 'Since AG-1425, only proteins will be pinned from Protein url'
+      }
+    },
+    async ({ page }) => {
+      const url = `${URL_GCT_PROTEIN_TMT}&${formatPinnedGenesQueryParam([
+        geneWithMultipleProteinsTMT.ensemblId,
+      ])}`;
+      await page.goto(url);
+      await expectGctPageLoaded(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      await confirmPinnedItemsByGeneName(
+        page,
+        geneWithMultipleProteinsTMT.name,
+        geneWithMultipleProteinsTMT.uniProtIds.length
+      );
+
+      await test.step('confirm counts', async () => {
+        await confirmPinnedItemsCount(page, 5);
+        await expectPinnedGenesCountText(page, 1);
+        await expectPinnedProteinsCountText(page, 5);
+      });
+    }
+  );
+
+  test(
+    'when Protein url includes 50 proteins from 50 unique genes, all proteins are pinned',
+    async ({ page }) => {
+      const url = `${URL_GCT_PROTEIN_TMT}&${formatPinnedGenesQueryParam(
+        fiftyProteinsToFiftyUniqueGenesTMT
+      )}`;
+      await page.goto(url);
+      await expectGctPageLoaded(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      await test.step('confirm counts', async () => {
+        await confirmPinnedItemsCount(page, 50);
+        await expectPinnedGenesCountText(page, 50);
+        await expectPinnedProteinsCountText(page, 50);
+      });
+    }
+  );
+
+  test(
+    'when Protein url includes >50 proteins from 50 unique genes, all proteins are pinned',
+    async ({ page }) => {
+      const fortyNineProteinsToUniqueGenes =
+        fiftyProteinsToFiftyUniqueGenesTMT.slice(0, -1);
+      const oneGeneWithManyProteins =
+        geneWithMultipleProteinsTMT.uniProtIds.map(
+          (uniProtId) => `${geneWithMultipleProteinsTMT.ensemblId}${uniProtId}`
+        );
+      const allProteins = [
+        ...fortyNineProteinsToUniqueGenes,
+        ...oneGeneWithManyProteins,
+      ];
+      const url = `${URL_GCT_PROTEIN_TMT}&${formatPinnedGenesQueryParam(
+        allProteins
+      )}`;
+
+      await page.goto(url);
+
+      await expectGctPageLoaded(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      await test.step('confirm counts', async () => {
+        await expectPinnedGenesCountText(page, 50);
+        await confirmPinnedItemsCount(page, allProteins.length);
+        await expectPinnedProteinsCountText(page, allProteins.length);
+      });
+
+      await confirmPinnedItemsByGeneName(
+        page,
+        geneWithMultipleProteinsTMT.name,
+        geneWithMultipleProteinsTMT.uniProtIds.length
+      );
+    }
+  );
+
+  test(
+    'when Protein url includes proteins from 51 unique genes, only proteins from 50 genes are pinned',
+    async ({ page }) => {
+      const oneGeneWithManyProteins =
+        geneWithMultipleProteinsTMT.uniProtIds.map(
+          (uniProtId) => `${geneWithMultipleProteinsTMT.ensemblId}${uniProtId}`
+        );
+      const allProteins = [
+        ...fiftyProteinsToFiftyUniqueGenesTMT,
+        ...oneGeneWithManyProteins,
+      ];
+      const expectedPinnedProteins = [
+        ...fiftyProteinsToFiftyUniqueGenesTMT.slice(0, -1),
+        ...oneGeneWithManyProteins,
+      ];
+
+      const url = `${URL_GCT_PROTEIN_TMT}&${formatPinnedGenesQueryParam(
+        allProteins
+      )}`;
+
+      await page.goto(url);
+
+      await expectGctPageLoaded(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      await test.step('confirm counts', async () => {
+        await expectPinnedGenesCountText(page, 50);
+        await confirmPinnedItemsCount(page, expectedPinnedProteins.length);
+        await expectPinnedProteinsCountText(
+          page,
+          expectedPinnedProteins.length
+        );
+      });
+    }
+  );
+
+  test(
+    'when Protein url includes invalid protein, that protein is dropped from the url',
+    async ({ page }) => {
+      const validGeneProtein = fiftyProteinsToFiftyUniqueGenesTMT[1];
+      const url = `${URL_GCT_PROTEIN_TMT}&${formatPinnedGenesQueryParam([
+        validGeneProtein,
+        'invalidGeneProtein',
+      ])}`;
+      await page.goto(url);
+
+      await expectGctPageLoaded(
+        page,
+        GCT_CATEGORIES.PROTEIN,
+        GCT_PROTEIN_SUBCATEGORIES.TMT
+      );
+
+      await test.step('confirm toast not shown', async () => {
+        await expect(page.getByRole('alert')).not.toBeVisible();
+      });
+
+      await test.step('confirm only pinned 1 protein', async () => {
+        await expectPinnedGenesCountText(page, 1);
+        await confirmPinnedItemsCount(page, 1);
+        await expectPinnedProteinsCountText(page, 1);
+      });
+
+      await test.step('confirm url dropped invalid protein', () => {
+        const geneProteins = getPinnedItemsFromUrl(page.url());
+        expect(geneProteins).toHaveLength(1);
+        expect(geneProteins).toEqual([validGeneProtein]);
+      });
+    }
+  );
+});
diff --git a/tests/gene-comparison-tool.spec.ts b/tests/gene-comparison-tool.spec.ts
index 9a3f12c5..50f7d55d 100644
--- a/tests/gene-comparison-tool.spec.ts
+++ b/tests/gene-comparison-tool.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect } from '@playwright/test';
+import { URL_GCT_PROTEIN } from './helpers/constants';
 import { waitForSpinnerNotVisible } from './helpers/utils';
 
 test.describe('specific viewport block', () => {
@@ -6,10 +7,10 @@ test.describe('specific viewport block', () => {
   test.use({ viewport: { width: 1600, height: 1200 } });
 
   test('has title', async ({ page }) => {
-    await page.goto('/genes/comparison?category=Protein+-+Differential+Expression');
+    await page.goto(URL_GCT_PROTEIN);
 
     // wait for page to load (i.e. spinner to disappear)
-    await waitForSpinnerNotVisible(page);
+    await waitForSpinnerNotVisible(page, 250000);
 
     // Expect a title "to contain" a substring.
     await expect(page).toHaveTitle('Gene Comparison | Visual comparison tool for AD genes');
@@ -17,7 +18,7 @@ test.describe('specific viewport block', () => {
 
   test('sub-category is SRM by default', async ({ page }) => {
     // set category for Protein - Differential Expression
-    await page.goto('/genes/comparison?category=Protein+-+Differential+Expression');
+    await page.goto(URL_GCT_PROTEIN);
 
     // wait for page to load (i.e. spinner to disappear)
     await waitForSpinnerNotVisible(page, 150000);
diff --git a/tests/gene-details.spec.ts b/tests/gene-details.spec.ts
index 6e7258a4..9d22c37d 100644
--- a/tests/gene-details.spec.ts
+++ b/tests/gene-details.spec.ts
@@ -8,12 +8,13 @@ test.describe('specific viewport block', () => {
   test('invalid gene results in a 404 redirect', async ({ page }) => {
     // go to invalid ENSG page
     await page.goto('/genes/ENSG00000000000');
+    await waitForSpinnerNotVisible(page);
 
     // expect a title "to contain" a substring.
     await expect(page).toHaveTitle('Agora');
 
     // expect div for page not found content to be visible
-    expect(page.locator('.page-not-found')).toBeVisible();
+    await expect(page.locator('.page-not-found')).toBeVisible();
   });
 
   test('consistency of change section heading is visible when using anchor link', async ({ page}) => {
@@ -24,6 +25,6 @@ test.describe('specific viewport block', () => {
     await waitForSpinnerNotVisible(page);
 
     const header = page.getByRole('heading', { name:  'Consistency of Change in Expression'});
-    expect(header).toBeInViewport();
+    await expect(header).toBeInViewport();
   });
-});
\ No newline at end of file
+});
diff --git a/tests/gene-similar.spec.ts b/tests/gene-similar.spec.ts
index 29341bb4..586efee8 100644
--- a/tests/gene-similar.spec.ts
+++ b/tests/gene-similar.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect } from '@playwright/test';
+import { waitForSpinnerNotVisible } from './helpers/utils';
 
 test.describe('specific viewport block', () => {
   test.slow();
@@ -7,11 +8,12 @@ test.describe('specific viewport block', () => {
   test('invalid gene results in a 404 redirect', async ({ page }) => {
     // go to invalid ENSG page
     await page.goto('/genes/ENSG00000000000/similar');
+    await waitForSpinnerNotVisible(page);
 
     // expect a title "to contain" a substring.
     await expect(page).toHaveTitle('Agora');
 
     // expect div for page not found content to be visible
-    expect(page.locator('.page-not-found')).toBeVisible();
+    await expect(page.locator('.page-not-found')).toBeVisible();
   });
-});
\ No newline at end of file
+});
diff --git a/tests/helpers/constants.ts b/tests/helpers/constants.ts
new file mode 100644
index 00000000..1b4ba4d1
--- /dev/null
+++ b/tests/helpers/constants.ts
@@ -0,0 +1,21 @@
+export const GCT_CATEGORIES = {
+  RNA: 'RNA - Differential Expression',
+  PROTEIN: 'Protein - Differential Expression',
+};
+
+export const GCT_RNA_SUBCATEGORIES = {
+  AD: 'AD Diagnosis (males and females)',
+  AD_AOD: 'AD Diagnosis x AOD (males and females)',
+  AD_SEX_F: 'AD Diagnosis x Sex (females only)',
+  AD_SEX_M: 'AD Diagnosis x Sex (males only)',
+};
+
+export const GCT_PROTEIN_SUBCATEGORIES = {
+  SRM: 'Targeted Selected Reaction Monitoring (SRM)',
+  TMT: 'Genome-wide Tandem Mass Tag (TMT)',
+  LFQ: 'Genome-wide Label-free Quantification (LFQ)',
+};
+
+export const URL_GCT = '/genes/comparison';
+export const URL_GCT_PROTEIN = `${URL_GCT}?category=${GCT_CATEGORIES.PROTEIN}`;
+export const URL_GCT_PROTEIN_TMT = `${URL_GCT_PROTEIN}&subCategory=TMT`;
diff --git a/tests/helpers/data.ts b/tests/helpers/data.ts
new file mode 100644
index 00000000..53d6b43e
--- /dev/null
+++ b/tests/helpers/data.ts
@@ -0,0 +1,119 @@
+export const fiftyGenes = [
+  'ENSG00000008283',
+  'ENSG00000089041',
+  'ENSG00000089250',
+  'ENSG00000095970',
+  'ENSG00000103197',
+  'ENSG00000106066',
+  'ENSG00000107099',
+  'ENSG00000107902',
+  'ENSG00000110514',
+  'ENSG00000112294',
+  'ENSG00000124299',
+  'ENSG00000125877',
+  'ENSG00000126602',
+  'ENSG00000130203',
+  'ENSG00000130414',
+  'ENSG00000130702',
+  'ENSG00000132561',
+  'ENSG00000134324',
+  'ENSG00000138095',
+  'ENSG00000140945',
+  'ENSG00000141338',
+  'ENSG00000142192',
+  'ENSG00000143252',
+  'ENSG00000144455',
+  'ENSG00000146648',
+  'ENSG00000147852',
+  'ENSG00000153113',
+  'ENSG00000158864',
+  'ENSG00000158887',
+  'ENSG00000160285',
+  'ENSG00000161011',
+  'ENSG00000161904',
+  'ENSG00000162688',
+  'ENSG00000164347',
+  'ENSG00000171608',
+  'ENSG00000178209',
+  'ENSG00000182512',
+  'ENSG00000185532',
+  'ENSG00000186153',
+  'ENSG00000186868',
+  'ENSG00000187323',
+  'ENSG00000196126',
+  'ENSG00000197535',
+  'ENSG00000197912',
+  'ENSG00000197943',
+  'ENSG00000204287',
+  'ENSG00000204525',
+  'ENSG00000214960',
+  'ENSG00000234745',
+  'ENSG00000273079',
+];
+
+export const fiftyOneGenes = [...fiftyGenes, 'ENSG00000100504'];
+
+export const geneWithMultipleProteinsTMT = {
+  name: 'GFAP',
+  ensemblId: 'ENSG00000131095',
+  uniProtIds: ['K7EKD1', 'K7ELP4', 'K7EPI4', 'P14136', 'P14136-3'],
+};
+export const gene2WithMultipleProteinsTMT = {
+  name: 'PLEC',
+  ensemblId: 'ENSG00000178209',
+  uniProtIds: ['Q15149', 'Q15149-3', 'Q15149-8'],
+};
+
+// Includes 50 unique genes for a specific protein in TMT dataset
+export const fiftyProteinsToFiftyUniqueGenesTMT = [
+  'ENSG00000003147Q05084',
+  'ENSG00000023228P28331',
+  'ENSG00000038427P13611',
+  'ENSG00000069966O14775',
+  'ENSG00000078674Q15154',
+  'ENSG00000091140P09622',
+  'ENSG00000100504P06737',
+  'ENSG00000103485Q15274',
+  'ENSG00000103723Q13367-2',
+  'ENSG00000104763Q13510',
+  'ENSG00000105607Q92947',
+  'ENSG00000106976Q05193',
+  'ENSG00000108515P13929',
+  'ENSG00000118473Q9BQI5-5',
+  'ENSG00000126267P14854',
+  'ENSG00000130203P02649',
+  'ENSG00000130414O95299',
+  'ENSG00000132470P16144-3',
+  'ENSG00000134324Q14693',
+  'ENSG00000136153Q8WWI1-2',
+  'ENSG00000138095P42704',
+  'ENSG00000139180F5GY40',
+  'ENSG00000141295J3QL71',
+  'ENSG00000141338O94911-3',
+  'ENSG00000143603A0A087WYJ0',
+  'ENSG00000150995Q14643-2',
+  'ENSG00000151150A0A087WVC2',
+  'ENSG00000151655P19823',
+  'ENSG00000151834E9PBQ7',
+  'ENSG00000158864O75306',
+  'ENSG00000159082C9JFZ1',
+  'ENSG00000160789P02545',
+  'ENSG00000162946Q9NRI5',
+  'ENSG00000163596F8WBQ1',
+  'ENSG00000172803Q86XE0',
+  'ENSG00000174469Q9UHC6',
+  'ENSG00000174886Q86Y39',
+  'ENSG00000175161Q8N3J6',
+  'ENSG00000175287Q5SRE7',
+  'ENSG00000178209Q15149',
+  'ENSG00000183117E5RIG2',
+  'ENSG00000183454Q12879',
+  'ENSG00000196126P20039',
+  'ENSG00000197912Q9UQ90',
+  'ENSG00000197943P16885',
+  'ENSG00000198087Q9Y5K6',
+  'ENSG00000204287P01903',
+  'ENSG00000213722O95865',
+  'ENSG00000261701P00739',
+  'ENSG00000273079Q13224',
+];
diff --git a/tests/helpers/gct-pinning.ts b/tests/helpers/gct-pinning.ts
new file mode 100644
index 00000000..87023f49
--- /dev/null
+++ b/tests/helpers/gct-pinning.ts
@@ -0,0 +1,136 @@
+import test, { expect, Page } from '@playwright/test';
+import { convertToQueryParam } from './utils';
+import { getGeneRowButtons } from './gct';
+
+export const closePinnedGeneWarningModal = async (page: Page) => {
+  await test.step('click through warning modal', async () => {
+    const dialog = page.getByRole('dialog').filter({
+      hasText: /you will lose some of your pins if you proceed/i,
+    });
+    const proceedBtn = dialog.getByRole('button', { name: 'Proceed' });
+    await proceedBtn.click();
+    await expect(dialog).not.toBeVisible();
+  });
+};
+
+export const formatPinnedGenesQueryParam = (pinnedGenes: string[]) => {
+  return convertToQueryParam(pinnedGenes, 'pinned');
+};
+
+export const expectPinnedGenesCountText = async (
+  page: Page,
+  nGenes: number
+) => {
+  await expect(page.getByText(`Pinned Genes (${nGenes}/50)`)).toBeVisible();
+};
+
+export const expectPinnedProteinsCountText = async (
+  page: Page,
+  nProteins: number
+) => {
+  await expect(
+    page.getByText(`${nProteins} Protein${nProteins > 1 ? 's' : ''}`)
+  ).toBeVisible();
+};
+
+export const expectTooManyPinnedGenesToast = async (page: Page) => {
+  const alert = page.getByRole('alert');
+  await expect(alert).toHaveText(
+    'Only 50 rows were added, because you reached the maximum of 50 pinned Ensembl identifiers.'
+  );
+};
+
+export const getPinnedItemsFromUrl = (url: string) => {
+  const queryString = url.split('?');
+  if (queryString.length !== 2) return null;
+
+  const urlParams = new URLSearchParams(queryString[1]);
+  const genesString = urlParams.get('pinned');
+  return genesString?.split(/%2C|,/);
+};
+
+export const confirmPinnedItemsCount = async (page: Page, nPinned: number) => {
+  await test.step(`confirm pinned items count is ${nPinned}`, async () => {
+    const rows = page.locator('tr.pinned');
+    const rowsCount = await rows.count();
+    expect(rowsCount).toBe(nPinned);
+  });
+};
+
+export const confirmPinnedItemsByGeneName = async (
+  page: Page,
+  geneName: string,
+  nItems: number
+) => {
+  await test.step(`confirm ${nItems} pinned items for ${geneName}`, async () => {
+    const rows = page.getByRole('row').filter({ hasText: geneName });
+    const nRows = await rows.count();
+    expect(nRows).toEqual(nItems);
+
+    for (let i = 0; i < nRows; ++i) {
+      await expect(rows.nth(i)).toHaveClass(/pinned/i);
+    }
+  });
+};
+
+export const confirmPinnedItemsByItemName = async (
+  page: Page,
+  itemNames: string[]
+) => {
+  for (const itemName of itemNames) {
+    await confirmPinnedItemsByGeneName(page, itemName, 1);
+  }
+};
+
+export const confirmPinnedProteins = async (
+  page: Page,
+  geneName: string,
+  proteins: string[]
+) => {
+  const geneProteins = proteins.map((protein) => `${geneName} (${protein})`);
+  await confirmPinnedItemsByItemName(page, geneProteins);
+};
+
+// assumes that geneName will resolve to a single search result
+export const pinGeneViaSearch = async (page: Page, geneName: string) => {
+  await test.step(`search for a gene named ${geneName}`, async () => {
+    const search = page.getByPlaceholder('Search', { exact: true });
+    await search.fill(geneName);
+  });
+
+  await test.step('pin the gene', async () => {
+    const btns = await getGeneRowButtons(page, geneName);
+    await btns.pin.click();
+  });
+};
+
+// assumes that each geneName will resolve to a single search result
+export const pinMultipleGenesViaSearch = async (
+  page: Page,
+  geneNames: string[]
+) => {
+  await test.step('pin genes', async () => {
+    let pinnedCount = 0;
+    for (const gene of geneNames) {
+      await pinGeneViaSearch(page, gene);
+      pinnedCount++;
+      await expectPinnedGenesCountText(page, pinnedCount);
+      await confirmPinnedItemsByGeneName(page, gene, 1);
+    }
+  });
+};
+
+export const pinAllItemsViaSearchByGene = async (
+  page: Page,
+  geneName: string
+) => {
+  await test.step(`search for items named ${geneName}`, async () => {
+    const search = page.getByPlaceholder('Search', { exact: true });
+    await search.fill(geneName);
+  });
+
+  await test.step('pin the gene', async () => {
+    const pinAllBtn = page.getByRole('button', { name: 'Pin All' });
+    await pinAllBtn.click();
+  });
+};
diff --git a/tests/helpers/gct.ts b/tests/helpers/gct.ts
new file mode 100644
index 00000000..03927b54
--- /dev/null
+++ b/tests/helpers/gct.ts
@@ -0,0 +1,126 @@
+import { Page, expect, test } from '@playwright/test';
+import { waitForSpinnerNotVisible } from './utils';
+import {
+  GCT_CATEGORIES,
+  GCT_PROTEIN_SUBCATEGORIES,
+  GCT_RNA_SUBCATEGORIES,
+} from './constants';
+
+export const expectGctPageLoaded = async (
+  page: Page,
+  category: string,
+  subcategory: string,
+  closeHelpDialog = true
+) => {
+  await test.step('wait for GCT page to load', async () => {
+    if (closeHelpDialog) await closeGctHelpDialog(page);
+
+    await waitForSpinnerNotVisible(page);
+
+    await expect(
+      page.getByRole('heading', { name: 'Gene Comparison Tool' })
+    ).toBeVisible();
+
+    await expect(
+      page.getByRole('button', { name: 'Filter Genes' })
+    ).toBeVisible();
+    await expect(page.getByRole('button', { name: 'Share URL' })).toBeVisible();
+
+    await expect(page.getByText(category)).toBeVisible();
+    await expect(page.getByText(subcategory)).toBeVisible();
+  });
+};
+
+export const closeGctHelpDialog = async (page: Page) => {
+  await test.step('close GCT help dialog', async () => {
+    const dialog = page.getByRole('dialog');
+    await expect(dialog).toHaveText(/Gene Comparison Overview/i);
+
+    const closeBtn = dialog.getByRole('button').first();
+    await closeBtn.click();
+
+    await expect(dialog).not.toBeVisible();
+  });
+};
+
+export const getGeneRowButtons = async (page: Page, name: string) => {
+  const geneName = page.locator('.gene-controls').filter({ hasText: name });
+  await geneName.hover();
+
+  const buttons = page.getByRole('cell', { name: name }).getByRole('button');
+  const count = await buttons.count();
+  expect(count).toBe(2);
+
+  return {
+    open: buttons.first(),
+    pin: buttons.nth(1),
+  };
+};
+
+const changeGctDropdown = async (
+  page: Page,
+  current: string,
+  desired: string
+) => {
+  await test.step(`change dropdown to ${desired}`, async () => {
+    const url = page.url();
+
+    await test.step('open dropdown', async () => {
+      const menu = page.getByText(current);
+      await menu.click();
+    });
+
+    await test.step('wait for dropdown to stabilize', async () => {
+      // Must wait for the listbox displaying the options to be stable
+      // ...before attempting to click on an option
+      // ...otherwise, clicking an option will be flaky and intermittently fail
+      const listbox = await page.$('ul[role=listbox]');
+      await listbox?.waitForElementState('stable');
+    });
+
+    const option = await test.step('select new option', async () => {
+      const option = page.getByRole('option', { name: desired });
+      await option.click({ timeout: 30_000 });
+      return option;
+    });
+
+    await test.step('wait for page to redirect', async () => {
+      await expect(() => {
+        expect(page.url()).not.toEqual(url);
+      }).toPass({ timeout: 60_000 });
+    });
+
+    // Handle case where listbox doesn't close after page redirects
+    await test.step('ensure dropdown closes', async () => {
+      await page.keyboard.press('Escape');
+      await expect(option).not.toBeVisible();
+    });
+  });
+};
+
+export const changeGctSubcategory = async (
+  page: Page,
+  category: string,
+  currentSubCategory: string,
+  desiredSubCategory: string
+) => {
+  await test.step(`change to ${desiredSubCategory} subcategory`, async () => {
+    await changeGctDropdown(page, currentSubCategory, desiredSubCategory);
+    await expectGctPageLoaded(page, category, desiredSubCategory, false);
+  });
+};
+
+export const changeGctCategory = async (
+  page: Page,
+  currentCategory: string,
+  desiredCategory: string
+) => {
+  await test.step(`change to ${desiredCategory} category`, async () => {
+    const defaultSubcategory =
+      desiredCategory === GCT_CATEGORIES.RNA
+        ? GCT_RNA_SUBCATEGORIES.AD
+        : GCT_PROTEIN_SUBCATEGORIES.SRM;
+    await changeGctDropdown(page, currentCategory, desiredCategory);
+    await expectGctPageLoaded(page, desiredCategory, defaultSubcategory, false);
+  });
+};
diff --git a/tests/helpers/utils.ts b/tests/helpers/utils.ts
index e6d122f3..184326b9 100644
--- a/tests/helpers/utils.ts
+++ b/tests/helpers/utils.ts
@@ -1,7 +1,14 @@
 import { Page, expect } from '@playwright/test';
 
-export const waitForSpinnerNotVisible = async (page: Page, timeout = 250000) => {
+export const waitForSpinnerNotVisible = async (
+  page: Page,
+  timeout = 60 * 2 * 1000
+) => {
   await expect(
     page.locator('div:nth-child(4) > div > .spinner')
   ).not.toBeVisible({ timeout: timeout });
 };
+
+export const convertToQueryParam = (list: string[], queryKey: string) => {
+  return `${queryKey}=${list.join(',')}`;
+};
diff --git a/tests/homepage.spec.ts b/tests/homepage.spec.ts
index 83cae356..fbc9c5cb 100644
--- a/tests/homepage.spec.ts
+++ b/tests/homepage.spec.ts
@@ -35,15 +35,15 @@ test.describe('specific viewport block', () => {
     await page.goto('/');
 
     // Hamburger menu should be hidden for the desktop viewport
-    expect(page.locator('button.header-nav-toggle')).toBeHidden();
-    
+    await expect(page.locator('button.header-nav-toggle')).toBeHidden();
+
     // look for news link and click it
-    const newsLink = await page.getByRole('link', { name: 'News'});
+    const newsLink = page.getByRole('link', { name: 'News' });
 
     // news link should be visible on the home page
-    expect(newsLink).toBeVisible();
+    await expect(newsLink).toBeVisible();
 
     await newsLink.click();
     await expect(page).toHaveTitle('News | Agora Releases');
   });
-});
\ No newline at end of file
+});
diff --git a/tsconfig.base.json b/tsconfig.base.json
new file mode 100644
index 00000000..e0e252fd
--- /dev/null
+++ b/tsconfig.base.json
@@ -0,0 +1,37 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "outDir": "./dist/out-tsc",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "sourceMap": true,
+    "declaration": false,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "importHelpers": true,
+    "target": "es2017",
+    "module": "es2020",
+    "lib": ["es2020", "dom"],
+    "allowSyntheticDefaultImports": true
+  },
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true
+  },
+  "include": [
+    "./src/**/*.ts",
+    "./src/**/*.html",
+    "./src/**/*.scss",
+    "./tests/**.ts",
+    "./tests/**/**.ts",
+    "playwright.config.ts"
+  ]
+}
diff --git a/tsconfig.json b/tsconfig.json
index bd8923ae..b6f22b29 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,31 +1,5 @@
 {
-  "compileOnSave": false,
-  "compilerOptions": {
-    "baseUrl": "./src",
-    "outDir": "./dist/out-tsc",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": false,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "sourceMap": true,
-    "declaration": false,
-    "downlevelIteration": true,
-    "experimentalDecorators": true,
-    "moduleResolution": "node",
-    "importHelpers": true,
-    "target": "es2017",
-    "module": "es2020",
-    "lib": ["es2020", "dom"],
-    "allowSyntheticDefaultImports": true
-  },
-  "angularCompilerOptions": {
-    "enableI18nLegacyMessageIdFormat": false,
-    "strictInjectionParameters": true,
-    "strictInputAccessModifiers": true,
-    "strictTemplates": true
-  },
+  "extends": "./tsconfig.base.json",
   "exclude": [
     "./node_modules",
     "./dist",