Yes. For a household, a flatshare or a group of friends, a self-hosted Spliit instance on modest home hardware will feel as quick as the hosted version, even after years of expenses. Spliit is a small Next.js app backed by a PostgreSQL database, and the work it does per page is light: listing expenses, adding them up and working out who owes whom. Most of the slowdowns you will see come from things around it, such as a weak SD card, a sleepy home connection or an underpowered build step, not from the number of expenses itself.

TL;DR

  • Couples and small households, e.g. two partners logging groceries and rent: run Spliit on whatever always-on device you already own, because the load is so small that hardware choice barely matters.
  • Flatshares, e.g. five housemates with shared bills over several years: use a machine with an SSD rather than an SD card, since database disk access is the first thing to feel slow as history grows.
  • Travel groups, e.g. ten friends logging a two-week trip from their phones: prioritise a reliable remote connection over raw CPU, because the experience on the road depends on reaching your server, not on server speed.
  • Organisers running many groups, e.g. one person hosting groups for family, clubs and trips: give PostgreSQL enough RAM and set up regular backups, since the database becomes the asset worth protecting.
  • Non-technical users who want privacy without maintenance: pick a setup that handles updates and HTTPS for you, because a forgotten server is a bigger risk than a slow one.
  • Anyone who only splits a few bills a year: the free hosted instance at spliit.app may be enough, since self-hosting mainly buys you control, not speed.

The central tradeoff is simple: self-hosting Spliit costs you a little setup and upkeep, and in return your group's spending history lives on hardware you control.

Table of contents

  • What does Spliit actually do when you open a group?
  • What hardware does Spliit really need to run smoothly?
  • Does Spliit slow down after hundreds or thousands of expenses?
  • How does the number of groups and participants affect performance?
  • Why the PostgreSQL database matters more than the app server
  • Raspberry Pi, mini PC, NAS or VPS: which one fits Spliit?
  • Is the first build and every update going to be painfully slow?
  • How fast does Spliit feel on a phone away from home?
  • What do optional features like receipt scanning cost in speed and privacy?
  • Storage, backups and exports: how much space does your history take?
  • Spliit versus Splitwise: what you gain and lose by self-hosting
  • Data sovereignty: who sees your group's spending?
  • Which setup should you choose for your situation?

What does Spliit actually do when you open a group?

Before you can judge whether a server is fast enough, it helps to know what work it is being asked to do. Spliit has no user accounts. A group is identified by a long ID in its URL, and anyone with that link can open it. Your browser remembers recently visited groups in local storage, so the server never keeps a list of who you are.

When you tap a group, the steps are short and predictable:

  • Page request: your browser asks the Next.js server, which listens on port 3000 by default, for the group page. The server renders the layout and sends it back.
  • Database queries: through the Prisma library, the app asks PostgreSQL for the group's details, its participants and its expenses. These are simple lookups by group ID, the kind of query PostgreSQL answers in very little time on almost any hardware.
  • Balance calculation: the app adds up who paid and who owes for each expense, then works out a short list of suggested reimbursements so the group settles with as few transfers as possible. This is arithmetic over the group's expenses, not heavy computing.
  • Rendering the list: the expense list, totals and tabs such as balances and statistics are drawn in your browser. On an old phone, this step can take longer than anything the server did.
  • Saving changes: adding or editing an expense is one small write to the database, followed by a refresh of the list.

Nothing here involves video, large files or background jobs. That is why the rest of this article focuses on disk, network and database health rather than processor speed.

What hardware does Spliit really need to run smoothly?

Spliit does not publish official minimum requirements, and we will not invent them. What we can do is describe where its resource use comes from, so you can judge any device you already own. A running instance is two processes: the Node.js server for the Next.js app and a PostgreSQL database. Both sit idle almost all the time, waking briefly when someone opens a group or saves an expense.

Here is what each part of a machine contributes:

  • Processor: any 64-bit chip from the last decade, ARM or x86, has headroom for serving pages and calculating balances. The processor only matters during the build step, covered later in this article.
  • Memory: the Node.js process and PostgreSQL each hold a modest working set in RAM. Their combined footprint grows slowly with use, so check it with docker stats after a week of real use rather than guessing up front.
  • Storage type: this is the component that most affects how Spliit feels. An SSD answers database reads quickly and survives constant small writes. A microSD card is slower for this pattern and wears out over time.
  • Storage size: expenses are rows of text and numbers, so a few gigabytes free covers the app, the database and years of history. Receipt images, if you enable them, are a separate question.
  • Uptime and network: a device that sleeps or loses its connection makes Spliit unreachable, which feels far worse than a slow page.

You can meet these needs on a home server, a NAS that supports Docker, a small VPS or a managed option. Yundera is a managed Personal Cloud Server, built on CasaOS, that runs self-hosted apps as Docker containers on a server dedicated to the user.

Does Spliit slow down after hundreds or thousands of expenses?

This is the question most people searching for Spliit performance actually have. The honest answer is that growth is gradual, and the parts that grow are easy to name. We have no published benchmark to quote, so instead of inventing timings, the table below shows what changes as a single group's history gets longer.

History in one group What grows What you are likely to notice
50 expenses, e.g. one weekend trip Almost nothing No difference from an empty group
500 expenses, e.g. a couple over two years The expense list and the balance sum Pages still feel immediate on an SSD
2,000 expenses, e.g. a flatshare over several years Data sent to the browser and work to draw the list Older phones may scroll or render more slowly before the server does
10,000 expenses, e.g. a heavily used long-running group Database reads per page and the balance calculation Worth checking disk type, RAM for PostgreSQL and phone age

Two points stand out. First, the balance calculation is a sum over rows, so its cost rises in a straight line with the number of expenses, not explosively. PostgreSQL handles tables of this size routinely. Second, the browser often becomes the bottleneck before the server, because a long list has to be drawn on the device in your hand.

If you want to know where your own group stands, count the rows directly. Running SELECT count(*) FROM "Expense"; inside the database container with psql gives you a real number in seconds. Compare it against how the app feels, and you will know whether growth is a real concern or a theoretical one.

How does the number of groups and participants affect performance?

Expense count is only one dimension. If you host Spliit for family, a sports club and a few trips, you will also wonder whether 20 groups or a 15-person group changes anything. The short answer is that groups barely interact, while participants add a little work to each page.

Here is how each kind of growth behaves:

  • More groups: each group is fetched by its own ID from the URL, so opening one group only reads that group's rows. Having 5 or 50 groups on the same instance makes little difference to how any single group loads. The extra cost is mostly disk space and a larger backup.
  • More participants in a group: every participant adds a row to the balance table and another person the reimbursement suggestions must account for. Going from 4 to 15 people makes that calculation larger, but it is still simple arithmetic and stays well within what a small machine handles.
  • Complex splits: Spliit lets you split an expense evenly, by shares, by percentage or by exact amounts. Uneven splits store a little more data per expense, but they do not change the shape of the work.
  • Many people using it at once: a travel group of 10 adding dinner costs at the same moment creates 10 small writes. That is a light burst for PostgreSQL, not a sustained load.
  • No accounts to manage: because Spliit has no logins, there is no session store, password hashing or user table growing alongside your groups. That removes a whole class of overhead found in comparable apps.

In practice, the participant count of your busiest group matters more than how many groups exist.

Why the PostgreSQL database matters more than the app server

The Next.js server is the part you see, but PostgreSQL is the part that decides whether Spliit stays quick and whether your data survives. The app server holds almost nothing of its own. Restart it, rebuild it or replace it, and every group comes back exactly as it was, because every participant, expense and category lives in the database.

That shifts where your attention should go:

  • Default memory settings: PostgreSQL ships with shared_buffers set to 128 MB. For a database of household expenses, that cache is already large enough to keep active groups in memory, so you rarely need to tune it.
  • Connection limits: the default max_connections is 100. Prisma keeps a small pool of connections from the app, so a family or friend group will never come close to that ceiling.
  • The data volume: in a Docker setup, the database files sit in a named volume or a bind-mounted folder. If that folder lives on a slow or failing disk, every page in Spliit inherits the problem, however fast the processor is.
  • Clean shutdowns: pulling the power on a running database risks a slow recovery on the next start. A small UPS or a device that shuts down gracefully protects both speed and data.
  • Version upgrades: moving between major PostgreSQL versions, for example from 15 to 16, needs a dump and restore with pg_dump. Changing the image tag alone will leave the container unable to start.

Whether you run the stack on a home server, a NAS, a VPS or Yundera, the rule is the same. Treat the database volume as the thing you are hosting, and the app container as replaceable.

Raspberry Pi, mini PC, NAS or VPS: which one fits Spliit?

Since Spliit's load is light, the choice of device comes down to reliability, remote access and how much maintenance you are willing to do. Prices vary too much by region and model to quote fairly, so the table compares the practical tradeoffs instead.

Option Where it fits Spliit well What to watch
Raspberry Pi 4 or 5 A low-power box at home for a couple or a flatshare Boot from an SSD over USB rather than a microSD card, use a 64-bit OS, and check that the image you use is published for arm64
Mini PC, e.g. an Intel N100 model Running Spliit beside several other self-hosted apps Higher idle power than a Pi, and you still handle remote access yourself
NAS with Docker, e.g. Synology Container Manager Households that already run a NAS around the clock Entry models with little RAM can get tight once other containers share it
Self-managed VPS Travel groups who need the app reachable from anywhere Your data sits in a provider's data centre, and you own updates, firewall and TLS
Managed personal cloud server, e.g. Yundera People who want a dedicated server without wiring compose files by hand Apps install from an app store and get a public HTTPS subdomain via NSL.SH, so no port forwarding is required

Two patterns stand out. Home devices keep your data physically close but make remote access your problem. Hosted options solve remote access but move the hardware out of your house. Neither choice is wrong for Spliit.

For most households, the right answer is the always-on device you already own, provided it has an SSD and a backup plan.

Is the first build and every update going to be painfully slow?

This is the one moment when Spliit asks real work of your hardware. Serving pages is light, but turning the source code into a production Next.js app is not. How painful it feels depends on whether you build the image yourself or pull one that is already built.

The main factors:

  • Building from source: the Spliit repository includes a Dockerfile and an npm run build-image script. That build installs Node.js dependencies and compiles the whole Next.js app, which is the most CPU and memory hungry step in the app's life. On a desktop it is a short wait. On a Raspberry Pi or an entry NAS it can take far longer and may fail if memory runs out.
  • Pulling a prebuilt image: if an image is published for your architecture, an update becomes a download with docker compose pull followed by a restart. No compiling happens on your device, so weak hardware stops being a factor.
  • Building elsewhere: if you must build, do it on a laptop or desktop and copy the finished image to the small device with docker save and docker load. This keeps the heavy step off the machine that runs Spliit.
  • Database migrations: when a new version changes the database structure, Prisma applies migrations as the app starts. On a household-sized database this is quick, but take a pg_dump first in case a migration fails.
  • Swap space: if you insist on building on a device with little RAM, adding a swap file can let the build finish instead of crashing, at the cost of a slower build.

The pattern to remember: slow hardware hurts during builds, not during daily use.

How fast does Spliit feel on a phone away from home?

For travel groups, this matters more than any processor. A phone on hotel Wi-Fi or mobile data reaches your server across the internet, and the slowest link in that path sets the pace. On a home connection, that is usually your upload speed, plus any detour your remote access method adds. Spliit can be added to a phone's home screen as a web app, but saving an expense still needs a live connection to your server.

The way you expose Spliit shapes both speed and who can use it:

Remote access method Effect on speed Effect on your group
Port forwarding plus a reverse proxy such as Caddy Direct path, limited by your home upload speed Anyone with the link can open it, but it fails behind carrier-grade NAT
Tailscale or WireGuard VPN Usually direct, sometimes relayed when a direct path fails Every participant must install and join the VPN, which friends often will not do
Cloudflare Tunnel Traffic passes through Cloudflare's network first Works behind any router, but a third party sits in the path of your data
Hosted server with a public HTTPS address No dependence on your home upload Easy to share, but the hardware lives outside your home

The key insight is social, not technical. Spliit works by sharing a group link, so the method you pick must work for the least technical person in your group. A VPN that keeps everything private is no help if half your travel companions never install it.

Before a trip, test from mobile data with Wi-Fi turned off. Add an expense, then open the balances tab. If that round trip feels slow, the bottleneck is the network path, not Spliit.

What do optional features like receipt scanning cost in speed and privacy?

Out of the box, Spliit stores only text and numbers. A few optional features, switched on through environment variables in your container.env file, change that picture. They do not slow down your server much, but they change where your data travels.

  • Expense documents: setting NEXT_PUBLIC_ENABLE_EXPENSE_DOCUMENTS lets people attach photos of receipts. Those files go to S3-compatible object storage configured with the S3_UPLOAD_* variables, not into PostgreSQL. You can point this at a self-hosted store such as MinIO to keep files at home, or at a cloud bucket, which places your receipts with that provider.
  • Receipt scanning: NEXT_PUBLIC_ENABLE_RECEIPT_EXTRACT reads the amount, date and title from a receipt photo. It requires an OPENAI_API_KEY, so every scanned image is sent to OpenAI. The wait comes from that external API call, not from your hardware, and each call is billed to your OpenAI account.
  • Category suggestions: NEXT_PUBLIC_ENABLE_CATEGORY_EXTRACT suggests a category from the expense title using the same OpenAI key. Only the title is sent, but that still means your spending descriptions leave your server.
  • Build-time settings: variables prefixed NEXT_PUBLIC_ are read by Next.js when the app is built. Depending on how your image is produced, turning a feature on or off may need a rebuild, which brings back the build cost discussed earlier.
  • Default state: all of these are off unless you enable them. A plain installation sends nothing to third parties.

For a privacy-focused setup, the clean choice is to leave AI features off and, if you want attachments, pair Spliit with self-hosted object storage.

Storage, backups and exports: how much space does your history take?

Each expense is a handful of short fields: a title, an amount, a date, who paid and how it was split. That is why Spliit's database stays small for a long time. Rather than trust a generic estimate, measure yours with SELECT pg_size_pretty(pg_database_size(current_database())); inside the database container. Note the result every few months and you will see your real growth rate. Receipt photos, if enabled, live in object storage and will outgrow the database quickly.

What matters more than size is having a copy you can restore. The three main options serve different purposes:

Method What it captures Best used for
pg_dump to a compressed .sql.gz file Every group, participant and expense on the instance Nightly scheduled backups and moving to new hardware
Copy of the stopped database volume The raw PostgreSQL files Quick snapshots before an update, only on the same PostgreSQL major version
Group export from the Spliit interface One group's expenses as a file you can open elsewhere Giving members their own copy, or leaving Spliit entirely
Object storage sync, e.g. with rclone Attached receipt images Setups that enable expense documents

A few habits keep this low effort. Schedule pg_dump with cron and keep at least 7 daily copies. Store one copy on a different device or location, following the familiar 3-2-1 rule. Test a restore into a spare container once, before you need it.

The group export deserves a special mention. Because Spliit has no accounts, any participant can export a group without asking the admin, which makes the data portable even if your server disappears.

Spliit versus Splitwise: what you gain and lose by self-hosting

Splitwise is the app most people are leaving when they look at Spliit, so it is the fair benchmark. Splitwise is a polished proprietary service with native iOS and Android apps, and its free tier now limits how many expenses you can add per day, with more features behind the paid Splitwise Pro plan. Spliit is open source under the MIT licence and has no paid tier at all.

Here is what actually changes when you move a group to your own Spliit instance:

  • You gain unlimited use: there is no daily expense cap and no feature locked behind a subscription. The only limits are the ones your own disk sets.
  • You gain account-free sharing: participants open a link instead of creating an account, so a friend joining a trip does not hand an email address to anyone.
  • You lose native apps: Spliit runs in the browser and can sit on a phone's home screen, but it does not have the native app polish or push notifications Splitwise users are used to.
  • You lose the managed service: with Splitwise, uptime, backups and security patches are someone else's job. Self-hosted, they become yours, as earlier sections on builds and backups showed.
  • You change who holds the data: Splitwise stores your group's spending on its own infrastructure. Self-hosted Spliit keeps it on the machine you chose, whether a home server, a NAS, a VPS or Yundera.
  • You change the failure mode: if Splitwise has an outage, everyone is affected and it gets fixed for you. If your server goes down, only your groups are affected and you are the one fixing it.

For speed alone, neither option has a decisive edge for household-sized groups.

Data sovereignty: who sees your group's spending?

Shared expenses reveal more than amounts. A year of entries shows where you live, who you travel with, which restaurants you visit and when you are away from home. With a hosted service, that pattern sits on someone else's servers under their privacy policy. With self-hosted Spliit, it sits wherever you put it, and that location decides which laws, providers and people can reach it.

Advantages of keeping Spliit on your own hardware:

  • No third-party profile: with AI features off, no company receives your spending history, names or habits.
  • Known jurisdiction: a server at home or in a chosen data centre keeps data under the laws of that country, which matters if you rely on rules such as the EU's GDPR.
  • No account trail: since Spliit asks for no email or password, there is no identity database to leak in the first place.
  • Your retention rules: you decide when old groups are deleted, rather than a provider's retention policy.

Privacy checklist for your instance:

  • Serve over HTTPS only: the group link travels in every request, so never expose Spliit over plain HTTP.
  • Treat the link like a password: anyone who has the group URL can read and edit it. Share it in private messages, not public chats.
  • Encrypt your backups: a pg_dump file is a full copy of every group. Encrypt it before it leaves the server, for example with gpg or age.
  • Keep AI keys out unless needed: leaving OPENAI_API_KEY empty guarantees no receipt or title is sent out.
  • Patch the host: update the operating system, Docker and the PostgreSQL image regularly.

Sovereignty is not automatic. It is the sum of these small choices.

Which setup should you choose for your situation?

Every earlier section points to the same conclusion: Spliit's speed is rarely the deciding factor. Your choice depends on who uses it, from where and how much upkeep you accept.

Profile Recommendation Main reason
Couple sharing household costs Existing home device with an SSD Load is tiny and both users are often on the home network
Flatshare of 4 to 6 people Raspberry Pi 5 or mini PC on an SSD Years of shared bills need durable storage more than speed
Travel group of 10 friends VPS or managed personal cloud server Members on mobile data need a public HTTPS address that just works
Organiser hosting 10 or more groups Mini PC or NAS with scheduled pg_dump Many groups make backups the priority
Non-technical privacy seeker Managed personal cloud server Updates and HTTPS are handled for you
Occasional user, a few bills a year Hosted instance at spliit.app Self-hosting buys control, not speed, at this scale
Tinkerer already running Docker Add Spliit to the existing stack Two more containers cost almost nothing

Next steps:

For home hardware:

  1. Move the system and Docker data to an SSD.
  2. Pull a prebuilt image, or build on a faster machine.
  3. Schedule a nightly pg_dump and test one restore.

For a VPS or managed server:

  1. Pick a data centre location whose laws you accept.
  2. Confirm HTTPS works from mobile data.
  3. Encrypt backups before they leave the server.

For the hosted instance:

  1. Export your groups regularly.
  2. Keep receipt scanning off if privacy matters.
  3. Revisit self-hosting if your group grows.