Most SaaS templates ship once and go stale. You buy something that looked great in the demo, clone it, and three months later you're chasing a CVE through 40 dependency PRs that nobody merged. The framework upgraded. The auth library rewrote its session API. The template author moved on.
This is the normal state of SaaS template maintenance — or the absence of it.
LaunchApp makes SaaS template maintenance automatic. Every 30 minutes, Animus sweeps all seven template repos, checks health gates, and opens fix PRs. And you can watch it happen in real time.
That's the Animus activity feed.
What the activity feed shows
Head to /animus and you'll see a live stream of the most recent 20 merged PRs across every LaunchApp repo. Each entry shows:
- The PR title and number
- Which repo it landed in
- Whether Animus authored it (marked with the Animus badge)
- How long ago it was merged
The feed refreshes every 60 seconds. No manual reload. If Animus just merged a security patch in launchapp-nuxt, it shows up.
Here's what a typical afternoon looks like:
✓ fix(deps): bump @better-auth/core 1.2.1 → 1.3.0 launchapp-nextjs Animus 3 min ago
✓ sync: add polar-sdk to launchapp-sveltekit launchapp-sveltekit Animus 18 min ago
✓ fix: resolve TypeScript strict error in auth middleware launchapp-crm Animus 31 min ago
✓ chore(deps): audit + patch 3 moderate vulnerabilities launchapp-nuxt Animus 47 min ago
✓ feat: add team invitations to lite-v2 launchapp-lite-v2 Animus 1 hr ago
This is not a marketing ticker. These are real GitHub PRs, fetched live from the launchapp-dev org.
Why we built it
Two reasons.
First, trust. When you're paying $199 for a SaaS starter, you're buying into a commitment that it stays current. Saying "we maintain everything" is easy. Showing the live merge stream is proof.
Second, it answers the question buyers actually ask: "Is this still being worked on?" Not whether there was a commit six weeks ago — but whether right now, today, the repos are being tended. The activity feed answers that without anyone needing to write a blog post about it.
How it works under the hood
The feed pulls from the GitHub REST API, querying the launchapp-dev org across seven repos:
launchapp-react-router(flagship)launchapp-nextjslaunchapp-nuxtlaunchapp-sveltekitlaunchapp-lite-v2launchapp-crmdesign-system
Each query fetches recently merged PRs. The API endpoint at /api/activity-feed aggregates them, sorts by merge time, and returns the 20 most recent. The client polls every 60 seconds.
Identifying Animus-authored PRs uses two signals: the PR labels (sweep, animus, conductor, health, sync) and the author username. PRs matching either get the Animus badge. Human PRs — reviewer feedback, one-off fixes — show up without it.
The distinction matters. You can tell at a glance which merges were autonomous maintenance and which were human decisions. Usually it's 80/20 Animus, which is the point.
What Animus actually maintains
If you haven't read how the conductor works, here's the short version.
Animus runs every 30 minutes. Each sweep covers:
Health gates. Build, lint, and test run against every repo. A failure gets flagged immediately and queued for a fix task. Build failures are the highest priority — they block everything downstream.
Dependency updates. Outdated packages get bumped. The fix runs health checks before opening a PR. If the update breaks something, Animus investigates and fixes the breakage in the same PR.
Security audits. pnpm audit runs on every sweep. Known CVEs are flagged by severity. Critical and high vulnerabilities skip the queue — they go straight to a fix task.
Feature parity. The flagship React Router template is the source of truth. When a new feature lands there, Animus diffs the other repos and opens sync PRs. The Next.js variant gets team invitations the same week the flagship does, not three months later.
PR review. Open PRs from human contributors get an automated review — checking for code quality, security issues, and design consistency — before a human merges.
All of this generates PRs. Those PRs are what you see in the activity feed.
What a SaaS template maintenance gap actually costs you
Let's be specific about the alternative.
You clone a template from a creator who last committed eight months ago. Your stack:
- Auth library shipped a breaking change in session handling. You need to migrate manually.
- Stripe SDK is two major versions behind. The webhook signature verification API changed.
- Three CVEs in transitive dependencies, none critical but all showing up in your Snyk dashboard when you demo to enterprise prospects.
- Framework upgrade — Next.js 15 dropped App Router RSC behavior that the template depended on. You're on your own.
None of this is dramatic. Each fix is an afternoon of work. But they add up to a week of catch-up before you can ship your first real feature — and this is a recurring tax, not a one-time cost.
Animus eliminates that tax. The repos stay current. Security patches land the same week they're published. Framework upgrades get handled before they become blockers.
When you buy a LaunchApp template, you're buying the current state of the stack — and the guarantee that it stays that way.
Reading the feed as a buyer
If you're evaluating LaunchApp, the activity feed is the best five minutes you can spend.
Open /animus and watch the stream for a minute. Look at:
- Frequency. How many PRs merged in the last 24 hours? You should see 30-60 on an average day, sometimes more.
- Spread. Are all seven repos getting attention, or just the flagship? Parity matters if you're buying the Next.js or Nuxt variant.
- Types. Mix of security patches, dep updates, and feature syncs is healthy. All dep bumps with no feature work might mean parity is slipping.
- Human vs. Animus. Some PRs should be human-authored — that means the team is making product decisions, not just running maintenance automation.
The feed won't have a good answer for you every time. Some weeks are maintenance-heavy. But it shows you the real cadence, unfiltered.
The changelog connection
The Animus activity feed and the changelog are linked. Every release entry pulls from the same merged PR data — Animus-authored merges are counted and attributed. So if you want a summary of what landed in a given period rather than a live stream, the changelog gives you that.
The activity feed is for now. The changelog is for history. Both show the same underlying work.
What this means for your product timeline
If you're building on a LaunchApp template, you're starting from a codebase that was maintained this morning. Not last quarter. This morning.
That changes the math on your launch timeline. You're not spending week one catching up on dependency drift. You're not discovering auth breakage when you first try to deploy. The stack is current, the health checks pass, and Animus keeps them passing.
Check the templates page to see which framework variant fits your stack. If you're starting from scratch and want the least friction, the flagship React Router template is where features land first. If you're on a Next.js team, the Next.js variant has full parity and the same maintenance guarantees.
Start with a maintained codebase
LaunchApp templates ship with full SaaS template maintenance on day one. No stale deps, no deferred security patches, no framework lag.
Browse the templates and watch the activity feed before you decide. The data is live.
If you're comparing options, check the pricing page — LaunchApp sits below Makerkit and Supastarter at $199 for the flagship, $399 for the full bundle. The difference is that you're not buying a snapshot. You're buying a maintained product.