I didn't build ShellSignal in ideal conditions.
I built it in a hostel in Nigeria, during JUPEB exams, on a limited data plan,
for a DEV Weekend Challenge with a hard deadline. No team. No staging server.
No time to configure Webpack or wire up a separate Express backend.
The stack either held up under pressure or it didn't.
It did. And this is the breakdown of why.
The Solo Dev Tax
Before you write a single line of product code, you're already bleeding time:
Do I use Vite or CRA? Where does my backend live? How do I handle auth tokens? Which cloud provider? Do I set up CI/CD now or later?
Two hours later, you have a configured project and zero features.
You are the frontend engineer, the DBA, the DevOps team, and the product
manager—simultaneously. Infrastructure setup and boilerplate auth can consume
70% of your time before you've touched the thing that actually matters:
your core product.
In 2026, my answer to that is the Next.js + Supabase + Vercel pipeline.
Here's exactly how it works and why.
Next.js: One Repo, Full Stack
Two package.json files. Two dev servers. Two deployment pipelines. Your
React frontend lives in one repo, your Node/Express backend in another, and
your brain is the unpaid glue holding them together.
Next.js collapses that into a single repository.
Your database query and the button that triggers it live in the same file.
This is not a minor convenience—it's a completely different way of working.
// app/actions/saveArticle.ts
'use server'
import { createClient } from '@/lib/supabase/server'
export async function saveArticle(articleId: string) {
const supabase = await createClient()
const { data: { user } } = await supabase.auth.getUser()
const { error } = await supabase
.from('saved_articles')
.insert({ user_id: user.id, article_id: articleId })
if (error) throw new Error(error.message)
}
// app/components/SaveButton.tsx
import { saveArticle } from '@/actions/saveArticle'
export function SaveButton({ articleId }: { articleId: string }) {
return (
<form action={saveArticle.bind(null, articleId)}>
<button type="submit">Save</button>
</form>
)
}
Server Action and UI component. Same codebase. No API contract to maintain
between repos. No extra round trip. No context switch.
The App Router gives you file-based routing, layouts, and streaming out of the
box. You scaffold with create-next-app and the structure is already sensible.
No Webpack config. No custom Babel setup.
Supabase: The Database That Comes With Everything
The managed backend space is crowded. Most options make you choose: speed of
setup, or power of queries. Pick one.
Supabase doesn't make you choose. You get PostgreSQL—a real relational
database with joins, transactions, and SQL you actually control—wrapped in an
API fast enough to use on day one of a weekend project.
Auth is a single client call:
// lib/supabase/client.ts
import { createBrowserClient } from '@supabase/ssr'
export const supabase = createBrowserClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
)
// Sign in with GitHub — no token logic, no session handling
await supabase.auth.signInWithOAuth({ provider: 'github' })
No token management. No refresh logic. No session handling from scratch.
Configure OAuth providers from the dashboard and move on.
Row Level Security kills an entire class of bugs:
-- Users can only read their own saved articles
create policy "Users read own saves"
on saved_articles for select
using (auth.uid() = user_id);
-- Users can only insert their own saves
create policy "Users insert own saves"
on saved_articles for insert
with check (auth.uid() = user_id);
That's it. No middleware. No if (article.userId !== req.user.id) return 403
scattered across your route handlers. Authorization lives at the database
level, enforced before your code even runs.
Real-time in three lines:
supabase
.channel('articles')
.on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'articles' },
(payload) => setArticles(prev => [payload.new, ...prev])
)
.subscribe()
No WebSocket server. No socket.io config. The data flows.
Vercel: The DevOps You Never Have to Think About
When you're solo, DevOps is the tax you pay for every feature you ship.
Vercel makes that tax as small as it can possibly be.
Push to main. Your app is live globally in seconds. No deployment scripts.
No SSH. No NGINX config.
Preview deployments mean every PR gets a unique live URL. Share it with a
client, test on a different device, or just sanity-check before merging.
It's a full QA environment you never had to provision.
Cron jobs without a server:
// vercel.json
{
"crons": [
{
"path": "/api/curate",
"schedule": "0 6 * * *"
}
]
}
// app/api/curate/route.ts
export async function GET() {
// Runs every morning at 6am — fetch, summarize, store
const articles = await fetchTrendingArticles()
await summarizeAndStore(articles)
return Response.json({ ok: true })
}
That cron wakes up every morning and curates ShellSignal's feed before a
single user opens the app. No external scheduler. No cron server. Just a
JSON config and a route handler.
The mobile angle: Because Vercel handles the build layer entirely, your
deployment pipeline doesn't require a machine. Commit from GitHub's web
editor. Check build logs from a browser tab. For those of us building
entirely from Android, this is the difference between shipping and not shipping.
How It All Came Together: ShellSignal
The problem I was solving was personal. As a student with constrained
bandwidth, keeping up with tech news was expensive. Most aggregators surface
everything. I needed signal, not noise.
Here's how the stack mapped to the actual product:
Next.js handled the full application layer. UI, API routes, and the
OpenRouter integration—Grok and Llama, model-routed depending on the request.
Every AI summary call ran through a Next.js API route. The GitHub Trending
cross-reference that powers the Dev Health badge—Stars vs. Open Issues scored
into a single metric—that logic lives in the same codebase as the component
that renders it.
Supabase managed user accounts and saved articles. The part worth calling
out is what I didn't write. No token refresh logic. No authorization guards
in route handlers. RLS handled it at the database level. For a weekend build
under exam pressure, that's hours returned to the actual product.
Vercel ran the morning cron that curates the feed and the edge functions
that keep AI summary latency low regardless of where the user hits the app
from. Aggressive caching kept bandwidth costs minimal—which mattered because
I understood that user firsthand.
The whole thing deployed from a push. I checked the build logs from my phone.
One developer. One weekend. One repo. A live, AI-integrated, real-time news
dashboard at the end of it.
Conclusion
You will eventually outgrow parts of this stack. That's fine—it means you
shipped something worth outgrowing.
Until then, the goal is to spend your hours on the problem you're solving,
not the infrastructure holding it together. This stack does that better than
anything else I've used.
Over to you: What's your go-to stack for shipping solo projects in 2026?
Are you team relational DB or NoSQL? Drop it in the comments.
Top comments (3)
The fact that you built ShellSignal during JUPEB exams on a mobile data plan is crazy dedication 🔥. The Vercel cron job setup for the AI summaries is super clean. Are you planning to add any other data sources to the dashboard soon?
Appreciate the hype, bro! 🔥 Honestly, surviving JUPEB and network fluctuations at the same time is a whole different kind of tech stack 😂. For the data sources, 100% expanding soon. I'm looking at hooking up Dev Community's API or some specific subreddits next. What sources do you usually check daily that I should add to the list?
Honest question for the solo devs out there: how much time do you usually burn just configuring your environments and auth before you write a single line of actual product code? This stack finally got that number down to near zero for me