diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 0e0e678b..0e3bf880 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -8,6 +8,19 @@ jobs:
     runs-on: ubuntu-latest
     env:
       SKIP_ENV_VALIDATION: true
+      DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/postgres"
+    services:
+      postgres:
+        image: ossapps/postgres
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
 
     steps:
       - name: Checkout
@@ -27,6 +40,11 @@ jobs:
       - name: Install dependencies
         run: pnpm install
 
+      - name: generate typedSQL types
+        run: |
+          pnpm db:dev
+          pnpm generate --sql
+
       - name: Apply prettier formatting
         run: pnpm prettier --check .
 
diff --git a/.gitignore b/.gitignore
index c8bd9af1..4c874e2b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,7 +11,7 @@
 # database
 /prisma/db.sqlite
 /prisma/db.sqlite-journal
-
+/src/prisma/client
 # next.js
 /.next/
 /out/
diff --git a/.oxlintrc.json b/.oxlintrc.json
index 54f2236f..b8a735a0 100644
--- a/.oxlintrc.json
+++ b/.oxlintrc.json
@@ -51,5 +51,5 @@
       }
     }
   ],
-  "ignorePatterns": ["prisma/seed.ts", "src/components/ui/*"]
+  "ignorePatterns": ["prisma/seed.ts", "src/components/ui/*", "prisma/largeSeed.ts"]
 }
diff --git a/prisma/largeSeed.ts b/prisma/largeSeed.ts
new file mode 100644
index 00000000..172f1562
--- /dev/null
+++ b/prisma/largeSeed.ts
@@ -0,0 +1,127 @@
+import { PrismaClient, SplitType, User, Group } from '@prisma/client';
+import { randomInt } from 'crypto';
+
+const prisma = new PrismaClient();
+
+async function createUsers() {
+  const data = Array.from({ length: 1000 }, (value, index) => index).map((i) => {
+    return {
+      name: `user${i}`,
+      email: `user${i}@example.com`,
+      currency: 'USD',
+    };
+  });
+  const users = await prisma.user.createMany({
+    data: data,
+  });
+  return prisma.user.findMany({
+    orderBy: {
+      id: 'asc',
+    },
+  });
+}
+
+async function createGroups(users: User[]) {
+  if (users.length) {
+    for (let i = 0; i < 100; i++) {
+      const s = i * 10;
+      const e = (i + 1) * 10 - 1;
+
+      // group of 10
+      const group = await prisma.group.create({
+        data: {
+          name: `Group_10_${i}`,
+          publicId: `Group-10-${i}`,
+          defaultCurrency: 'EUR',
+          userId: users[s].id,
+        },
+      });
+
+      await prisma.groupUser.createMany({
+        data: users.slice(s, e).map((u) => {
+          return {
+            groupId: group.id,
+            userId: u.id,
+          };
+        }),
+      });
+    }
+  }
+
+  const group = await prisma.group.create({
+    data: {
+      name: `Group_30`,
+      publicId: `Group-30`,
+      defaultCurrency: 'EUR',
+      userId: users[0].id,
+    },
+  });
+
+  await prisma.groupUser.createMany({
+    data: users.slice(0, 29).map((u) => {
+      return {
+        groupId: group.id,
+        userId: u.id,
+      };
+    }),
+  });
+
+  return prisma.group.findMany({
+    include: {
+      groupUsers: true,
+    },
+  });
+}
+
+async function createExpenses(groups: Group[]) {
+  const currencies = ['EUR', 'USD'];
+  for (const gid in groups) {
+    const group = groups[gid];
+    for (let i = 0; i < 10000; i++) {
+      const c = randomInt(0, 2);
+      const amount = BigInt(randomInt(1000, 10000));
+
+      const expense = await prisma.expense.create({
+        data: {
+          name: `Expense Group ${group.id} ${i}`,
+          paidBy: group.groupUsers[0].userId,
+          addedBy: group.groupUsers[0].userId,
+          category: 'general',
+          currency: currencies[c],
+          amount: amount,
+          groupId: group.id,
+          splitType: SplitType.EQUAL,
+        },
+      });
+
+      await prisma.expenseParticipant.createMany({
+        data: [
+          { expenseId: expense.id, userId: group.groupUsers[0].userId, amount: amount },
+          ...group.groupUsers.slice(1).map((u) => {
+            return {
+              expenseId: expense.id,
+              userId: u.userId,
+              amount: -amount / BigInt(group.groupUsers.length),
+            };
+          }),
+        ],
+      });
+    }
+  }
+}
+
+async function main() {
+  const users = await createUsers();
+  const groups = await createGroups(users);
+  await createExpenses(groups);
+  console.log('Seeded db with users, groups and expenses');
+}
+
+main()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(() => {
+    prisma.$disconnect().catch(console.log);
+  });
diff --git a/prisma/migrations/20250618113146_add_expense_participant_userid_index/migration.sql b/prisma/migrations/20250618113146_add_expense_participant_userid_index/migration.sql
new file mode 100644
index 00000000..39f57ea4
--- /dev/null
+++ b/prisma/migrations/20250618113146_add_expense_participant_userid_index/migration.sql
@@ -0,0 +1,2 @@
+-- CreateIndex
+CREATE INDEX "ExpenseParticipant_userId_idx" ON "ExpenseParticipant" USING HASH ("userId");
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index a5e68d40..905c4aae 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -1,6 +1,6 @@
 generator client {
   provider        = "prisma-client-js"
-  previewFeatures = ["relationJoins"]
+  previewFeatures = ["relationJoins", "typedSQL"]
 }
 
 datasource db {
@@ -208,6 +208,7 @@ model ExpenseParticipant {
   expense   Expense @relation(fields: [expenseId], references: [id], onDelete: Cascade)
 
   @@id([expenseId, userId])
+  @@index([userId], type: Hash)
   @@schema("public")
 }
 
diff --git a/prisma/sql/getAllBalancesForGroup.sql b/prisma/sql/getAllBalancesForGroup.sql
new file mode 100644
index 00000000..1c2e726c
--- /dev/null
+++ b/prisma/sql/getAllBalancesForGroup.sql
@@ -0,0 +1,21 @@
+-- @param {Int} $1:id of the group
+SELECT
+    "groupId",
+    "userId" AS "borrowedBy",
+    "paidBy",
+    "currency",
+    CAST(Coalesce(-1 * sum("ExpenseParticipant".amount), 0) AS BIGINT) AS amount
+FROM
+    "Expense"
+    JOIN "ExpenseParticipant" ON "ExpenseParticipant"."expenseId" = "Expense".id
+WHERE
+    "groupId" = $1
+    AND "userId" != "paidBy"
+    AND "Expense"."deletedAt" IS NULL
+GROUP BY
+    "userId",
+    "paidBy",
+    "currency",
+    "groupId"
+ORDER BY
+    "currency"
diff --git a/prisma/sql/getGroupsWithBalances.sql b/prisma/sql/getGroupsWithBalances.sql
new file mode 100644
index 00000000..38bb5e60
--- /dev/null
+++ b/prisma/sql/getGroupsWithBalances.sql
@@ -0,0 +1,24 @@
+-- @param {Int} $1:id of the user
+SELECT
+    "Group"."id",
+    "Group".name,
+    CAST(Coalesce(sum("ExpenseParticipant".amount), 0) AS BIGINT) AS balance,
+    Coalesce("Expense".currency, "Group"."defaultCurrency") AS currency,
+    "Group"."archivedAt"
+FROM
+    "GroupUser"
+    JOIN "Group" ON "GroupUser"."groupId" = "Group".id
+    LEFT JOIN "Expense" ON "Expense"."groupId" = "Group".id
+    LEFT JOIN "ExpenseParticipant" ON "Expense".id = "ExpenseParticipant"."expenseId"
+WHERE
+    "GroupUser"."userId" = $1
+    AND "deletedAt" IS NULL
+    AND ("ExpenseParticipant"."userId" = $1
+        OR "Expense".id IS NULL)
+GROUP BY
+    "Group".id,
+    "Group".name,
+    "Expense".currency
+ORDER BY
+    "Group"."createdAt" DESC,
+    balance DESC
diff --git a/src/components/Expense/BalanceList.tsx b/src/components/Expense/BalanceList.tsx
index 9ce731c7..12f128ac 100644
--- a/src/components/Expense/BalanceList.tsx
+++ b/src/components/Expense/BalanceList.tsx
@@ -1,4 +1,7 @@
-import type { GroupBalance, User } from '@prisma/client';
+import type { User } from '@prisma/client';
+import { type getAllBalancesForGroup } from '@prisma/client/sql';
+import { Info } from 'lucide-react';
+
 import { clsx } from 'clsx';
 import { type ComponentProps, Fragment, useCallback, useMemo } from 'react';
 import { EntityAvatar } from '~/components/ui/avatar';
@@ -19,9 +22,10 @@ interface UserWithBalance {
 }
 
 export const BalanceList: React.FC<{
-  groupBalances?: GroupBalance[];
-  users?: User[];
-}> = ({ groupBalances = [], users = [] }) => {
+  groupId: number;
+  groupBalances: getAllBalancesForGroup.Result[];
+  users: User[];
+}> = ({ groupId, groupBalances, users }) => {
   const { displayName, t } = useTranslationWithUtils();
   const userQuery = api.user.me.useQuery();
 
@@ -34,16 +38,17 @@ export const BalanceList: React.FC<{
       return acc;
     }, {});
     groupBalances
-      .filter(({ amount }) => 0 < BigMath.abs(amount))
+      .filter(({ amount }) => amount != null && BigMath.abs(amount) > 0)
       .forEach((balance) => {
-        if (!res[balance.userId]!.balances[balance.firendId]) {
-          res[balance.userId]!.balances[balance.firendId] = {};
+        if (!res[balance.paidBy]!.balances[balance.borrowedBy]) {
+          res[balance.paidBy]!.balances[balance.borrowedBy] = {};
         }
-        const friendBalance = res[balance.userId]!.balances[balance.firendId]!;
-        friendBalance[balance.currency] = (friendBalance[balance.currency] ?? 0n) + balance.amount;
+        const friendBalance = res[balance.paidBy]!.balances[balance.borrowedBy]!;
+        friendBalance[balance.currency] =
+          (friendBalance[balance.currency] ?? 0n) + (balance.amount ?? 0n);
 
-        res[balance.userId]!.total[balance.currency] =
-          (res[balance.userId]!.total[balance.currency] ?? 0n) + balance.amount;
+        res[balance.paidBy]!.total[balance.currency] =
+          (res[balance.paidBy]!.total[balance.currency] ?? 0n) + (balance.amount ?? 0n);
       });
 
     return res;
@@ -164,7 +169,7 @@ export const BalanceList: React.FC<{
                               user={user}
                               amount={amount}
                               currency={currency}
-                              groupId={groupBalances[0]!.groupId}
+                              groupId={groupId}
                             >
                               <Button size="icon" variant="secondary" className="size-8">
                                 <SETTLEUP_ICON className="size-4" />
diff --git a/src/components/group/GroupMyBalance.tsx b/src/components/group/GroupMyBalance.tsx
index 25e8c9ec..802efdc8 100644
--- a/src/components/group/GroupMyBalance.tsx
+++ b/src/components/group/GroupMyBalance.tsx
@@ -1,4 +1,5 @@
-import { type GroupBalance, type User } from '@prisma/client';
+import { type User } from '@prisma/client';
+import { type getAllBalancesForGroup } from '@prisma/client/sql';
 import React from 'react';
 import { useTranslation } from 'next-i18next';
 
@@ -6,8 +7,8 @@ import { BigMath, toUIString } from '~/utils/numbers';
 
 interface GroupMyBalanceProps {
   userId: number;
-  groupBalances?: GroupBalance[];
-  users?: User[];
+  groupBalances: getAllBalancesForGroup.Result[] | undefined;
+  users: User[] | undefined;
 }
 
 const GroupMyBalance: React.FC<GroupMyBalanceProps> = ({
@@ -26,10 +27,13 @@ const GroupMyBalance: React.FC<GroupMyBalanceProps> = ({
 
   const friendBalances = groupBalances.reduce(
     (acc, balance) => {
-      if (balance.userId === userId && 0 < BigMath.abs(balance.amount)) {
-        acc[balance.firendId] ??= {};
-        const friendBalance = acc[balance.firendId]!;
-        friendBalance[balance.currency] = (friendBalance[balance.currency] ?? 0n) + balance.amount;
+      if (balance.paidBy === userId && balance.amount != null && BigMath.abs(balance.amount) > 0) {
+        if (!acc[balance.borrowedBy]) {
+          acc[balance.borrowedBy] = {};
+        }
+        const friendBalance = acc[balance.borrowedBy]!;
+        friendBalance[balance.currency] =
+          (friendBalance[balance.currency] ?? 0n) + (balance.amount ?? 0n);
       }
       return acc;
     },
diff --git a/src/lib/simplify.test.ts b/src/lib/simplify.test.ts
index 958b421e..3afda86e 100644
--- a/src/lib/simplify.test.ts
+++ b/src/lib/simplify.test.ts
@@ -1,5 +1,4 @@
-import { type GroupBalance } from '@prisma/client';
-import { addHours } from 'date-fns';
+import { type getAllBalancesForGroup } from '@prisma/client/sql';
 
 import { simplifyDebts } from './simplify';
 
@@ -9,46 +8,45 @@ interface MinimalEdge {
   amount: bigint;
 }
 
-const sortByIds = (a: GroupBalance, b: GroupBalance) => {
-  if (a.userId === b.userId) {
-    return a.firendId - b.firendId;
+const sortByIds = (a: getAllBalancesForGroup.Result, b: getAllBalancesForGroup.Result) => {
+  if (a.paidBy === b.paidBy) {
+    return a.borrowedBy - b.borrowedBy;
   }
-  return a.userId - b.userId;
+  return a.paidBy - b.paidBy;
 };
 
-let dateCounter = 0;
-
-const edgeToGroupBalance = (edge: MinimalEdge): [GroupBalance, GroupBalance] => {
+const edgeToGroupBalance = (
+  edge: MinimalEdge,
+): [getAllBalancesForGroup.Result, getAllBalancesForGroup.Result] => {
   const base = {
     groupId: 0,
     currency: 'USD',
-    updatedAt: addHours(new Date(), dateCounter++),
   };
   return [
     {
-      userId: edge.userOne,
-      firendId: edge.userTwo,
+      paidBy: edge.userOne,
+      borrowedBy: edge.userTwo,
       amount: edge.amount,
       ...base,
     },
     {
-      userId: edge.userTwo,
-      firendId: edge.userOne,
-      amount: 0n === edge.amount ? 0n : -edge.amount,
+      paidBy: edge.userTwo,
+      borrowedBy: edge.userOne,
+      amount: edge.amount === 0n ? 0n : -edge.amount,
       ...base,
     },
   ];
 };
 
-const padWithZeroBalances: (balances: GroupBalance[], userCount: number) => GroupBalance[] = (
-  balances,
-  userCount,
-) => {
+const padWithZeroBalances: (
+  balances: getAllBalancesForGroup.Result[],
+  userCount: number,
+) => getAllBalancesForGroup.Result[] = (balances, userCount) => {
   const result = [...balances];
   for (let userId = 0; userId < userCount; userId++) {
     for (let friendId = userId + 1; friendId < userCount; friendId++) {
       const found = balances.find(
-        (balance) => balance.userId === userId && balance.firendId === friendId,
+        (balance) => balance.paidBy === userId && balance.borrowedBy === friendId,
       );
 
       if (!found) {
@@ -59,14 +57,17 @@ const padWithZeroBalances: (balances: GroupBalance[], userCount: number) => Grou
   return result;
 };
 
-const getFullBalanceGraph = (edges: MinimalEdge[], userCount: number): GroupBalance[] => {
+const getFullBalanceGraph = (
+  edges: MinimalEdge[],
+  userCount: number,
+): getAllBalancesForGroup.Result[] => {
   const arr = padWithZeroBalances(edges.flatMap(edgeToGroupBalance), userCount);
   arr.sort(sortByIds);
   return arr;
 };
 
 // taken from https://www.geeksforgeeks.org/minimize-cash-flow-among-given-set-friends-borrowed-money/
-const smallGraph: GroupBalance[] = getFullBalanceGraph(
+const smallGraph: getAllBalancesForGroup.Result[] = getFullBalanceGraph(
   [
     { userOne: 0, userTwo: 1, amount: 1000n },
     { userOne: 1, userTwo: 2, amount: 5000n },
@@ -75,19 +76,16 @@ const smallGraph: GroupBalance[] = getFullBalanceGraph(
   3,
 );
 
-const smallGraphResult: GroupBalance[] = getFullBalanceGraph(
+const smallGraphResult: getAllBalancesForGroup.Result[] = getFullBalanceGraph(
   [
     { userOne: 1, userTwo: 2, amount: 4000n },
     { userOne: 2, userTwo: 0, amount: -3000n },
   ],
   3,
-).map((resultBalance, idx) => ({
-  ...resultBalance,
-  updatedAt: smallGraph[idx]!.updatedAt,
-}));
+);
 
 // taken from https://medium.com/@mithunmk93/algorithm-behind-splitwises-debt-simplification-feature-8ac485e97688
-const largeGraph: GroupBalance[] = getFullBalanceGraph(
+const largeGraph: getAllBalancesForGroup.Result[] = getFullBalanceGraph(
   [
     { userOne: 1, userTwo: 2, amount: 4000n },
     { userOne: 1, userTwo: 5, amount: -1000n },
@@ -105,7 +103,7 @@ const largeGraph: GroupBalance[] = getFullBalanceGraph(
   7,
 );
 
-const denseGraph: GroupBalance[] = getFullBalanceGraph(
+const denseGraph: getAllBalancesForGroup.Result[] = getFullBalanceGraph(
   [
     { userOne: 0, userTwo: 1, amount: 895795n },
     { userOne: 0, userTwo: 2, amount: 328043n },
@@ -142,7 +140,9 @@ describe('simplifyDebts', () => {
     { graph: largeGraph, expected: 3 },
     { graph: denseGraph, expected: 5 },
   ])('gets the optimal operation count', ({ graph, expected }) => {
-    expect(simplifyDebts(graph).filter((balance) => 0 < balance.amount).length).toBe(expected);
+    expect(simplifyDebts(graph).filter((balance) => (balance.amount ?? 0n) > 0).length).toBe(
+      expected,
+    );
   });
 
   it.each([{ graph: smallGraph }, { graph: largeGraph }, { graph: denseGraph }])(
@@ -150,7 +150,7 @@ describe('simplifyDebts', () => {
     ({ graph }) => {
       const startingBalances = graph.reduce(
         (acc, balance) => {
-          acc[balance.userId] = (acc[balance.userId] ?? 0n) + balance.amount;
+          acc[balance.paidBy] = (acc[balance.paidBy] ?? 0n) + (balance.amount ?? 0n);
           return acc;
         },
         {} as Record<number, bigint>,
@@ -158,7 +158,7 @@ describe('simplifyDebts', () => {
 
       const userBalances = simplifyDebts(graph).reduce(
         (acc, balance) => {
-          acc[balance.userId] = (acc[balance.userId] ?? 0n) + balance.amount;
+          acc[balance.paidBy] = (acc[balance.paidBy] ?? 0n) + (balance.amount ?? 0n);
           return acc;
         },
         {} as Record<number, bigint>,
diff --git a/src/lib/simplify.ts b/src/lib/simplify.ts
index 52871788..429338e8 100644
--- a/src/lib/simplify.ts
+++ b/src/lib/simplify.ts
@@ -1,13 +1,15 @@
-import type { GroupBalance } from '@prisma/client';
+import { type getAllBalancesForGroup } from '@prisma/client/sql';
 
-export function simplifyDebts(groupBalances: GroupBalance[]): GroupBalance[] {
+export function simplifyDebts(
+  groupBalances: getAllBalancesForGroup.Result[],
+): getAllBalancesForGroup.Result[] {
   const currencies = new Set(groupBalances.map((balance) => balance.currency));
   const nodes = new Set<number>();
   groupBalances.forEach((balance) => {
-    nodes.add(balance.userId);
-    nodes.add(balance.firendId);
+    nodes.add(balance.paidBy);
+    nodes.add(balance.borrowedBy);
   });
-  const result: GroupBalance[] = [];
+  const result: getAllBalancesForGroup.Result[] = [];
 
   for (const currency of currencies) {
     const balances = groupBalances.filter((balance) => balance.currency === currency);
@@ -19,29 +21,31 @@ export function simplifyDebts(groupBalances: GroupBalance[]): GroupBalance[] {
 }
 
 function simplifyDebtsForSingleCurrency(
-  groupBalances: GroupBalance[],
+  groupBalances: getAllBalancesForGroup.Result[],
   nodes: number[],
-): GroupBalance[] {
+): getAllBalancesForGroup.Result[] {
   const adjMatrix = new Array<bigint[]>(nodes.length)
     .fill([])
     .map(() => new Array<bigint>(nodes.length).fill(0n));
 
-  const nonResidualBalances = groupBalances.filter((balance) => 0 < balance.amount);
+  const nonResidualBalances = groupBalances.filter(
+    (balance) => balance.amount != null && 0 < balance.amount,
+  );
 
   nonResidualBalances.forEach((balance) => {
-    const source = nodes.indexOf(balance.userId);
-    const sink = nodes.indexOf(balance.firendId);
-    adjMatrix[source]![sink] = balance.amount;
+    const source = nodes.indexOf(balance.paidBy);
+    const sink = nodes.indexOf(balance.borrowedBy);
+    adjMatrix[source]![sink] = balance.amount ?? 0n;
   });
 
   const simplified = minCashFlow(adjMatrix);
 
   const result = getMirrorBalances(
     simplified.flatMap((row, source) => {
-      const res: GroupBalance[] = [];
+      const res: getAllBalancesForGroup.Result[] = [];
       row.forEach((amount, sink) => {
         const balance = groupBalances.find(
-          (balance) => balance.userId === nodes[source] && balance.firendId === nodes[sink],
+          (balance) => balance.paidBy === nodes[source] && balance.borrowedBy === nodes[sink],
         )!;
 
         if (0n === amount) {
@@ -60,7 +64,7 @@ function simplifyDebtsForSingleCurrency(
   groupBalances.forEach((balance) => {
     const found = result.find(
       (graphBalance) =>
-        graphBalance.userId === balance.userId && graphBalance.firendId === balance.firendId,
+        graphBalance.paidBy === balance.paidBy && graphBalance.borrowedBy === balance.borrowedBy,
     );
     if (!found) {
       result.push({ ...balance, amount: 0n });
@@ -142,15 +146,17 @@ const constructMinMaxQ = (amounts: bigint[]): [Entry[], Entry[]] => {
   return [minQ, maxQ];
 };
 
-const getMirrorBalances = (groupBalances: GroupBalance[]): GroupBalance[] => {
+const getMirrorBalances = (
+  groupBalances: getAllBalancesForGroup.Result[],
+): getAllBalancesForGroup.Result[] => {
   const result = [...groupBalances];
 
   groupBalances.forEach((balance) => {
     result.push({
       ...balance,
-      userId: balance.firendId,
-      firendId: balance.userId,
-      amount: 0 < balance.amount ? -balance.amount : 0n,
+      paidBy: balance.borrowedBy,
+      borrowedBy: balance.paidBy,
+      amount: balance.amount != null && balance.amount > 0 ? -balance.amount : 0n,
     });
   });
 
diff --git a/src/pages/groups.tsx b/src/pages/groups.tsx
index 3f983c4a..d5a71735 100644
--- a/src/pages/groups.tsx
+++ b/src/pages/groups.tsx
@@ -51,15 +51,10 @@ const BalancePage: NextPageWithUser = () => {
             <>
               {/* Active Groups */}
               {groupQuery.data?.map((g) => {
-                const [currency, amount] = Object.entries(g.balances).reduce(
-                  (acc, balance) => {
-                    if (BigMath.abs(balance[1]) > BigMath.abs(acc[1])) {
-                      return balance;
-                    }
-                    return acc;
-                  },
-                  [g.defaultCurrency, 0n],
-                );
+                const [currency, amount] = Object.entries(g.balances).reduce((first, second) => {
+                  return BigMath.abs(second[1]) > BigMath.abs(first[1]) ? second : first;
+                });
+
                 const multiCurrency = 1 < Object.values(g.balances).filter((b) => 0n !== b).length;
                 return (
                   <BalanceEntry
diff --git a/src/pages/groups/[groupId].tsx b/src/pages/groups/[groupId].tsx
index 1b8f8699..fc1f1242 100644
--- a/src/pages/groups/[groupId].tsx
+++ b/src/pages/groups/[groupId].tsx
@@ -41,6 +41,7 @@ import { type NextPageWithUser } from '~/types';
 import { api } from '~/utils/api';
 import { customServerSideTranslations } from '~/utils/i18n/server';
 import { toUIString } from '~/utils/numbers';
+import { getAllBalancesForGroup } from '@prisma/client/sql';
 
 const BalancePage: NextPageWithUser<{
   enableSendingInvites: boolean;
@@ -91,7 +92,7 @@ const BalancePage: NextPageWithUser<{
     groupDetailQuery.data?.userId === user.id &&
     !groupDetailQuery.data?.groupBalances.find((bal) => 0n !== bal.amount);
   const canLeave = !groupDetailQuery.data?.groupBalances.find(
-    (bal) => 0n !== bal.amount && bal.userId === user.id,
+    (bal) => 0n !== bal.amount && bal.paidBy === user.id,
   );
 
   const onRecalculateBalances = useCallback(() => {
@@ -243,7 +244,7 @@ const BalancePage: NextPageWithUser<{
                         isAdmin &&
                         (() => {
                           const canLeave = !groupDetailQuery.data?.groupBalances.find(
-                            (b) => 0n !== b.amount && b.userId === groupUser.userId,
+                            (b) => b.amount !== 0n && b.paidBy === groupUser.userId,
                           );
 
                           return (
@@ -482,8 +483,9 @@ const BalancePage: NextPageWithUser<{
               </TabsContent>
               <TabsContent value="balances">
                 <BalanceList
-                  groupBalances={groupDetailQuery.data?.groupBalances}
-                  users={groupDetailQuery.data?.groupUsers.map((gu) => gu.user)}
+                  groupId={groupId}
+                  groupBalances={groupDetailQuery.data?.groupBalances ?? []}
+                  users={groupDetailQuery.data?.groupUsers.map((gu) => gu.user) ?? []}
                 />
               </TabsContent>
             </Tabs>
diff --git a/src/server/api/routers/group.ts b/src/server/api/routers/group.ts
index db4afe66..62529fd8 100644
--- a/src/server/api/routers/group.ts
+++ b/src/server/api/routers/group.ts
@@ -1,3 +1,6 @@
+import { SplitType } from '@prisma/client';
+import { getAllBalancesForGroup, getGroupsWithBalances } from '@prisma/client/sql';
+
 import { TRPCError } from '@trpc/server';
 import { nanoid } from 'nanoid';
 import { z } from 'zod';
@@ -52,46 +55,36 @@ export const groupRouter = createTRPCRouter({
   getAllGroupsWithBalances: protectedProcedure
     .input(z.object({ getArchived: z.boolean() }).optional())
     .query(async ({ ctx, input }) => {
-      const groups = await ctx.db.groupUser.findMany({
-        where: {
-          userId: ctx.session.user.id,
-          group: {
-            archivedAt: input?.getArchived ? { not: null } : null,
-          },
-        },
-        include: {
-          group: {
-            include: {
-              groupBalances: {
-                where: { userId: ctx.session.user.id },
-              },
-              expenses: {
-                orderBy: {
-                  createdAt: 'desc',
-                },
-                take: 1,
-              },
-            },
-          },
-        },
-      });
-
-      const sortedGroupsByLatestExpense = groups.sort((a, b) => {
-        const aDate = a.group.expenses[0]?.createdAt ?? new Date(0);
-        const bDate = b.group.expenses[0]?.createdAt ?? new Date(0);
-        return bDate.getTime() - aDate.getTime();
-      });
+      let groupBalances = await ctx.db.$queryRawTyped(getGroupsWithBalances(ctx.session.user.id));
 
-      const groupsWithBalances = sortedGroupsByLatestExpense.map((g) => {
-        const balances: Record<string, bigint> = {};
-
-        for (const balance of g.group.groupBalances) {
-          balances[balance.currency] = (balances[balance.currency] ?? 0n) + balance.amount;
-        }
+      // filter out archived groups if getArchived is false
+      if (!input?.getArchived) {
+        groupBalances.filter((b) => b.archivedAt != null);
+      }
+      const _groups = groupBalances
+        .map((b) => {
+          return {
+            id: b.id,
+            name: b.name,
+          };
+        })
+        .filter((obj, index, self) => index === self.findIndex((t) => t.id === obj.id));
+
+      const groupsWithBalances = _groups.map((group) => {
+        const balancesForGroup: Record<string, bigint> = {};
+        groupBalances
+          .filter((b) => {
+            return b.id == group.id;
+          })
+          .forEach((b) => {
+            if (b.currency != null && b.balance != null) {
+              balancesForGroup[b.currency] = b.balance;
+            }
+          });
 
         return {
-          ...g.group,
-          balances,
+          ...group,
+          balances: balancesForGroup,
         };
       });
 
@@ -122,7 +115,7 @@ export const groupRouter = createTRPCRouter({
     }),
 
   getGroupDetails: groupProcedure.query(async ({ input, ctx }) => {
-    const group = await ctx.db.group.findUnique({
+    const group = await ctx.db.group.findUniqueOrThrow({
       where: {
         id: input.groupId,
       },
@@ -132,15 +125,30 @@ export const groupRouter = createTRPCRouter({
             user: true,
           },
         },
-        groupBalances: true,
       },
     });
 
-    if (group?.simplifyDebts) {
-      group.groupBalances = simplifyDebts(group.groupBalances);
+    const balances = await ctx.db.$queryRawTyped(getAllBalancesForGroup(input.groupId));
+
+    const reverseBalances = balances.map((b) => {
+      return {
+        ...b,
+        borrowedBy: b.paidBy,
+        paidBy: b.borrowedBy,
+        amount: b.amount != null ? -b.amount : 0n,
+      };
+    });
+
+    const groupWithBalances = {
+      ...group,
+      groupBalances: balances.concat(reverseBalances),
+    };
+
+    if (groupWithBalances?.simplifyDebts) {
+      groupWithBalances.groupBalances = simplifyDebts(groupWithBalances.groupBalances);
     }
 
-    return group;
+    return groupWithBalances;
   }),
 
   getGroupTotals: groupProcedure.query(async ({ input, ctx }) => {
@@ -256,15 +264,11 @@ export const groupRouter = createTRPCRouter({
         });
       }
 
-      const groupBalances = await ctx.db.groupBalance.findMany({
-        where: {
-          groupId: input.groupId,
-        },
-      });
+      const groupBalances = await ctx.db.$queryRawTyped(getAllBalancesForGroup(input.groupId));
 
       const finalGroupBalances = group.simplifyDebts ? simplifyDebts(groupBalances) : groupBalances;
 
-      if (finalGroupBalances.some((b) => b.userId === userId && 0n !== b.amount)) {
+      if (finalGroupBalances.some((b) => b.paidBy === userId && 0n !== b.amount)) {
         throw new TRPCError({
           code: 'BAD_REQUEST',
           message: 'User has a non-zero balance in this group',
@@ -347,11 +351,9 @@ export const groupRouter = createTRPCRouter({
 
       // Only check balances when archiving (not when unarchiving)
       if (isArchiving) {
-        if (group?.simplifyDebts) {
-          group.groupBalances = simplifyDebts(group.groupBalances);
-        }
+        const groupBalances = await ctx.db.$queryRawTyped(getAllBalancesForGroup(input.groupId));
 
-        const balanceWithNonZero = group.groupBalances.find((b) => 0n !== b.amount);
+        const balanceWithNonZero = groupBalances.find((b) => 0n !== b.amount);
 
         if (balanceWithNonZero) {
           throw new TRPCError({
@@ -390,11 +392,9 @@ export const groupRouter = createTRPCRouter({
         throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Only creator can delete the group' });
       }
 
-      if (group?.simplifyDebts) {
-        group.groupBalances = simplifyDebts(group.groupBalances);
-      }
+      const groupBalances = await ctx.db.$queryRawTyped(getAllBalancesForGroup(input.groupId));
 
-      const balanceWithNonZero = group?.groupBalances.find((b) => 0n !== b.amount);
+      const balanceWithNonZero = groupBalances.find((b) => 0n !== b.amount);
 
       if (balanceWithNonZero) {
         throw new TRPCError({
diff --git a/tsconfig.json b/tsconfig.json
index d7cb57b6..ba83fcf4 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -39,5 +39,5 @@
     "**/*.js",
     ".next/types/**/*.ts"
   ],
-  "exclude": ["node_modules", "public"]
+  "exclude": ["node_modules", "public", "prisma/seed.ts", "prisma/largeSeed.ts"]
 }