Ask ChatGPT to help you create tables with the most important aspects of a big text. It’s better than bullet points, imo (when the text is really big). You can ask for some refinements like small definitions of the most important concepts, or wikipedia links, too (or your favorite website). You can also use PowerAutomate to interact with your browser and automate some of these commands.

Self-Host Strong, AI Agents Fast, & Master Your JSON Tools

Today’s Highlights

Today, we bring you critical resources for fortifying your self-hosted infrastructure, including a massive guide for production apps and a faster JSON processing tool. Dive into the future of AI with Cloudflare’s breakthrough in sandboxing AI agents for unprecedented speed and security.

Free 750-page guide to self-hosting production apps – NO AI SLOP (r/selfhosted)

Source: https://reddit.com/r/selfhosted/comments/1s51bg1/free_750page_guide_to_selfhosting_production_apps/

This extensive, free 750-page guide from a veteran self-hoster is an invaluable resource for anyone looking to deploy and manage production-grade applications on their own infrastructure. Eschewing generic, AI-generated content, the guide is packed with real-world experience gathered over a decade of running high-traffic services. It aims to empower developers to break free from vendor lock-in and gain full control over their deployments, directly addressing the PatentLLM Blog’s audience who prioritizes self-hosted solutions.

The guide covers a comprehensive range of topics essential for reliable production deployments, including system architecture, security best practices, performance optimization, and disaster recovery. For developers working with local LLMs, RTX GPUs, and other self-hosted hardware, understanding these foundational principles is crucial for building robust and scalable applications without relying on external cloud providers. It promises actionable insights and detailed instructions, making it a truly practical handbook for enhancing your self-hosting capabilities.

Comment: As someone running vLLM and Cloudflare Tunnel on my local servers, a guide like this is gold for ensuring my setup is robust and secure, not just for personal projects but for anything with significant traffic. I’m always looking for battle-tested advice on optimizing my infrastructure without AI fluff.

Sandboxing AI agents, 100x faster (Cloudflare Blog)

Source: https://blog.cloudflare.com/dynamic-workers/

Cloudflare’s new Dynamic Workers introduce a significant leap in sandboxing AI-generated code, promising execution speeds up to 100 times faster than traditional container-based approaches. This innovation addresses a critical challenge in AI agent development: securely and rapidly executing untrusted or dynamically generated code, crucial for iterative AI workflows and preventing exploits. The core technology leverages lightweight isolates, which offer minimal overhead and millisecond startup times, making them ideal for the ephemeral, high-frequency tasks often associated with AI agents.

For developers building agentic systems with local LLMs and RTX GPUs, the principles behind Dynamic Workers are highly relevant. While Cloudflare provides this as a service, the concept of secure, high-performance sandboxing for AI agents is transferable. It encourages thinking about how to design local execution environments that offer similar isolation and speed, whether through WASM runtimes or other lightweight virtualization techniques, to accelerate the development and deployment of complex AI-driven applications and ensure the integrity of your self-hosted LLM operations.

Comment: Executing AI-generated code securely and quickly is a major headache when building agents on my local RTX setup; this 100x speedup with lightweight isolates is exactly the kind of innovation needed to make complex agentic workflows practical without compromising security.

A Faster Alternative to Jq (Hacker News)

Source: https://micahkepe.com/blog/jsongrep/

Introducing jsongrep, a promising new command-line utility designed to be a significantly faster alternative to the ubiquitous jq for processing large JSON datasets. For developers who frequently interact with JSON output from APIs, logs, or local LLM inference results, jq is a staple, but its performance can become a bottleneck with multi-gigabyte files. jsongrep aims to alleviate this by providing optimized parsing and filtering capabilities, often leveraging modern systems programming languages like Rust or Go for inherent speed advantages.

This tool is a practical must-have for anyone managing self-hosted infrastructure, debugging complex LLM responses, or performing rapid data analysis on their local machines. Its focus on raw speed means less time waiting for commands to complete, enabling quicker iteration and more efficient data exploration. Developers can expect a familiar command-line interface that allows them to quickly extract, transform, and filter JSON data with minimal setup, making it an immediate upgrade for their daily toolkit.

Comment: My LLMs often spit out massive JSON logs, and jq can crawl; a faster alternative like jsongrep is an instant add to my self-hosted CLI toolkit for quicker debugging and data parsing.

AI is quickly becoming a new search layer.

People don’t just Google anymore — they ask ChatGPT, Claude, Gemini…

But here’s the problem:
Companies have no idea if they are visible in these answers.

So I built a tool to solve that.

Introducing GeoTracker

GeoTracker is a web app that analyzes how an AI perceives your company.

It answers questions like:

• Is my company mentioned in AI responses?
• Which competitors are shown instead?
• What sources are used by the AI?
• How can I improve my visibility?

How it works

The idea is simple:

1. Generate real-world prompts (like users would ask)
2. Send them to multiple AI models
3. Analyze the responses
4. Extract:
   • brand mentions
   • competitors
   • cited sources
5. Generate actionable recommendations

Core features

• Multi-model AI analysis (OpenAI, etc.)
• Manual prompt testing
• Batch testing (run multiple prompts at once)
• Brand & competitor detection
• Source extraction
• GEO recommendations engine
• PDF export for client reports

Tech stack

• Frontend: React + Vite
• Backend: FastAPI
• Database: PostgreSQL
• Infra: Docker + Nginx (VPS)
• Auth: Secure cookie (JWT)

Why this matters

We are entering a new era of search.

SEO is no longer enough.

We now need to optimize for AI-generated answers:
GEO (Generative Engine Optimization)

If your company is not mentioned in AI responses, you are invisible.

Example use case

Prompt:

“Best suppliers of slip rings in aerospace”

Result:

• Your company might not appear
• Competitors dominate
• Sources come from specific domains

That’s actionable data.

What’s next

I’m currently working on:

• automated monitoring
• scoring & trends
• multi-client SaaS version
• better recommendations engine

Final thoughts

This project started as an experiment, but it quickly turned into something bigger.

AI visibility is going to be a major challenge for companies in the next years.

And we’re just at the beginning.

If you’re working on SEO, AI, or similar tools, I’d love to connect

“I know — you’ve been working hard. Just maybe in the wrong direction. But hey, that ends today.”

Nobody wants to say it. So I will. 👇

Every year someone posts a “top skills to learn” list. Same advice, different year. Learn React. Learn Python. Learn cloud.

Fine. But nobody talks about the other side — the skills quietly becoming worthless while beginners spend months on them.

This is that post. No sugarcoating. ☕

💀 Skills That Are Dying (or Already Dead)

1. jQuery

jQuery was revolutionary… in 2010.

In 2026, it’s legacy code you’ll encounter in old codebases — not something to actively learn. Modern JavaScript does everything jQuery ever did:

// jQuery way (old)
$('.btn').on('click', () => { ... })

// Vanilla JS (modern)
document.querySelector('.btn').addEventListener('click', () => { ... })

Brutal truth: If jQuery is your main skill, you’re optimizing for maintaining 10-year-old projects — not getting hired anywhere building something new.

2. HTML/CSS Alone — Without JavaScript

“I know HTML and CSS” used to be a valid entry point.

In 2026, it gets you exactly one role: static site builder — and even that’s being eaten alive by AI tools like Framer and Webflow.

HTML and CSS are absolutely essential. But they’re the foundation, not the destination. If you stop there, you stop before the job market begins.

Brutal truth: No frontend job posting in 2026 says “JavaScript optional.” JS is the job. Period.

3. Basic WordPress Development

Building simple WordPress sites used to be a freelancer’s bread and butter. 🍞

Now? AI site builders — Framer AI, Wix AI, even ChatGPT — generate a decent business website in minutes.

Advanced WordPress (custom plugins, headless WP with React) still has a market. Basic theme installation does not.

Brutal truth: You’re entering a market that AI is actively pricing you out of.

4. Memorizing Syntax 🧠

Controversial one. Hear me out.

Spending hours memorizing JavaScript array methods or CSS property names is a poor investment in 2026. GitHub Copilot, ChatGPT, and Claude autocomplete all of it. Every senior dev already has multiple AI tools open while coding.

What can’t be automated? Understanding why something works. When to use it. How to debug it when it breaks.

Brutal truth: The dev who understands concepts deeply but uses AI for syntax will always beat the dev who memorized syntax but doesn’t understand the logic underneath.

5. Random CSS Hacks Without Understanding Layout 🤯

Googling random CSS fixes. Copy-pasting Stack Overflow snippets. Not knowing why z-index isn’t working.

This approach gets more painful every year. Tailwind CSS has standardized frontend styling. CSS Grid and Flexbox made layout predictable.

Brutal truth: Companies don’t want devs who copy-paste CSS blindly. They want devs who understand the box model, the cascade, and layout well enough to write it confidently.

🚀 Skills That Are Rising (Learn These NOW)

1. React + TypeScript ⚛️

This is the industry standard for frontend in 2026. Open any junior frontend job listing — you’ll see React. TypeScript has gone from “nice to have” to flat-out expected.

You don’t need to master TypeScript immediately. Even basic types and interfaces will put you ahead of beginners still writing plain JavaScript.

// TypeScript — simple but powerful
interface User {
  name: string;
  age: number;
  isLoggedIn: boolean;
}

Honest path: Learn React well first. Add TypeScript once you’re comfortable with components and state.

2. AI Tool Integration 🤖

This is the skill with the highest upside for a frontend developer right now.

Companies at every level — startups, agencies, enterprise — are scrambling to add AI features to their products. A developer who can integrate an AI API, handle streaming responses, and build a chat interface is genuinely valuable.

The technical barrier is lower than you think. If you can call a REST API in JavaScript, you can integrate an AI API.

const response = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: prompt }]
  })
})

Honest path: Build one AI-powered tool as a portfolio project. It immediately separates you from 90% of beginners.

3. Git + CI/CD Basics 🔧

Git is non-negotiable. Every team, every company, every freelance project uses version control.

CI/CD — even basic knowledge of how GitHub Actions works, how code auto-deploys — shows you think like a professional developer, not a hobbyist.

# GitHub Actions — auto deploy on push
on: [push]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm install && npm run build

Honest path: Use Git for every project, even solo ones. Set up a simple GitHub Actions workflow. That alone is resume-worthy.

4. System Design Thinking 🏗️

“Isn’t that for senior engineers?”

Nope. In 2026, even junior interviews at decent companies include basic system design questions. Not “design Twitter at scale” — but:

• How would you structure this feature?
• Why would you use a database here?
• What happens when this API fails?

This is just thinking about your code as a system rather than a collection of files.

Honest path: When you build projects, ask yourself: what if 1000 users used this? What breaks first? That mindset IS system design at the junior level.

5. Next.js + Full-Stack Thinking ⚡

Next.js is the dominant React framework for a reason — it handles routing, server-side rendering, API routes, and deployment in one package.

More importantly, it pushes you to think full-stack. You start understanding where data comes from, how APIs work, what the server is doing — all critical for growing beyond junior level.

Honest path: Once you’re solid in React, your next project should be a Next.js app deployed on Vercel. It’s the fastest way to level up your thinking.

🎯 The Real Skill Nobody Lists

Every list talks about frameworks and tools. Nobody talks about the actual meta-skill:

Learning speed. 🏃

The developer who learns React in a month beats the one spending a year on jQuery. The developer who ships imperfect projects and iterates beats the one waiting to feel “ready.”

Technologies keep changing. The skill that never becomes obsolete is the ability to pick up new things fast, build something with them, and move on.

📊 Quick Summary

💬 Your Turn

Disagree with anything on this list? Drop a comment — genuinely curious what you’d add or remove.

And if you’re just starting out and feeling overwhelmed by all this — don’t be. You don’t need to learn everything at once. Pick one “Rising” skill, go deep on it, and ship something. That’s the whole game. 🎮

Found this useful? Drop a ❤️ — it helps more beginners find this post!

How a carefully layered architecture delivers instant offline access, end-to-end privacy, and optional cloud sync, without asking you to choose between them.

Estimated reading time: 10 minutes

The Privacy Paradox of Financial Apps

Every financial app on the market asks you the same question on page one: “Create an account.” Before you can track a single expense, you hand over an email address. Before you can set a savings goal, your data lands on someone else’s server. You are trusting that company’s security practices, their terms of service, their business model, and their continued existence — all to do basic arithmetic with your own money.

Most apps treat this as inevitable. A login wall is the cost of admission. Your data goes to their database. You hope for the best.

Talliofi refuses that deal. Your data never leaves your device unless you explicitly ask it to. No account. No telemetry. No analytics. If you want cloud sync across devices, you bring your own Supabase instance. If you do not, everything stays local. Forever.

This sounds simple in a pitch deck. In code, it requires an architecture that most web apps never need to consider. This article is a complete walkthrough of how we built it.

What “Local-First” Actually Means

The local-first software movement, articulated by Ink & Switch in 2019, makes one core argument: the best software keeps your data on your device and treats sync as a convenience, not a requirement. The app works on a plane. It works when your connection drops mid-session. It works ten years from now, even if the company behind it disappears.

For Talliofi, local-first is not a philosophy; it is a set of concrete engineering constraints:

• No login required to use the full app. Open it, enter data, close the tab, come back next month. Everything is there.
• The device is the source of truth. IndexedDB, not a server, holds the canonical state.
• Sync is additive, not required. The app does not degrade without it.

This inverts the standard web app model. In a typical application, the server is the source of truth and the client is a view layer. In Talliofi, the client is the source of truth. The server, if present at all, is a backup.

Layer 1: IndexedDB as the Source of Truth

Talliofi uses Dexie, a thin TypeScript-friendly wrapper over IndexedDB, as its primary database. The schema spans 11 tables:

export class TalliofiDatabase extends Dexie {
  plans!: Table<Plan, string>;
  expenses!: Table<ExpenseItem, string>;
  goals!: Table<Goal, string>;
  assets!: Table<Asset, string>;
  liabilities!: Table<Liability, string>;
  snapshots!: Table<MonthlySnapshot, string>;
  netWorthSnapshots!: Table<NetWorthSnapshot, string>;
  changelog!: Table<ChangeLogEntry, string>;
  recurringTemplates!: Table<RecurringTemplate, string>;
  attachments!: Table<ExpenseAttachment, string>;
  vault!: Table<EncryptedVaultRecord, string>;
}

The schema is versioned. Dexie runs migrations sequentially when the schema version increases:

db.version(1).stores({ plans: 'id, name', expenses: 'id, planId', /* ... */ });
// ...
db.version(9).stores({
  // Adds compound index for date-range queries — critical for reports
  expenses: 'id, planId, [planId+transactionDate]',
});

That [planId+transactionDate] compound index in version 9 is a good example of performance-driven schema evolution. Expense reports filter by plan and date range constantly. Without the compound index, every date-range query scans all expenses for a plan. With it, IndexedDB finds the exact range in a single lookup. Schema versions let you add this kind of optimization incrementally, without a big-bang migration.

The result: opening Talliofi after a week away feels instant. No API call, no loading spinner, no authentication handshake. IndexedDB serves data in milliseconds.

Layer 2: TanStack Query as a Smart Cache, Not the Source of Truth

Here is the architectural distinction that most React apps get wrong: TanStack Query is a cache, not a database.

In a typical React + React Query app:

Component -> useQuery -> fetch from API -> display

In Talliofi:

Component -> useQuery -> read from Dexie -> display

The query function talks to IndexedDB, not a network endpoint. TanStack Query still earns its keep: caching, deduplication, background refresh, and stale-time management are genuinely useful even when the data source is local:

export function useExpensesByDateRange(
  planId: string | undefined,
  startDate: string,
  endDate: string,
) {
  return useQuery({
    queryKey: queryKeys.expensesRange(planId!, startDate, endDate),
    queryFn: () =>
      getExpenseRepo().getByPlanIdAndDateRange(planId!, startDate, endDate),
    enabled: !!planId && !!startDate && !!endDate,
    staleTime: PLAN_DATA_STALE_TIME_MS,
  });
}

The staleTime constant means Talliofi does not re-read from IndexedDB on every render. Fresh data serves from the in-memory cache. When a mutation writes to IndexedDB, it invalidates the relevant query keys, triggering a re-read. The component always shows the latest data without polling.

This separation is also what makes the next layer possible.

Layer 3: The Repo Router, One Interface, Three Backends

The central abstraction that makes local-first + optional sync work is the repo router. Every data access in the entire app goes through a function like this:

function isCloudMode(): boolean {
  const mode = useSyncStore.getState().storageMode;
  return mode === 'cloud' || mode === 'encrypted';
}

export function getExpenseRepo(): typeof expenseRepo {
  return isCloudMode() ? supabaseExpenseRepo : expenseRepo;
}

Components and hooks never import a specific repo directly. They call getExpenseRepo(). The function returns the right implementation based on the user’s chosen storage mode. Three modes exist:

The Dexie repo and the Supabase repo implement the same interface. Adding a new entity type means writing a new Dexie repo, a new Supabase repo, and registering both in the router. The components never change.

The Data Flow

User action (add expense)
        |
        v
useCreateExpense() hook
        |
        v
getExpenseRepo() --> local?  --> expenseRepo (Dexie)
                 -- cloud?  --> supabaseExpenseRepo (Supabase)
        |
        v
TanStack Query cache invalidated
        |
        v
UI re-renders with fresh data
        |
        v (async, fire-and-forget)
changelog table --> sync engine --> Supabase (on next push)

The sync engine runs in the background. A successful write to Dexie also writes to the local changelog. The sync engine periodically pushes changelog entries to Supabase and pulls remote changes. The UI never waits for sync to complete, local writes are instant.

Layer 4: The Sync Engine, Changelog Over Full-Table Sync

Syncing all data on every cycle works for small datasets but collapses as data grows. Talliofi uses a changelog-based approach instead.

Every create, update, and delete operation appends an entry to a local changelog table:

interface ChangeLogEntry {
  id: string;
  planId: string;
  entityType: 'expense' | 'bucket' | 'plan' | 'goal' | 'asset' | 'liability';
  entityId: string;
  operation: 'create' | 'update' | 'delete';
  timestamp: string;
  payload?: string; // Serialized entity data (encrypted if mode is 'encrypted')
}

On sync, the engine pushes only entries newer than the last sync watermark, a timestamp stored per plan. On pull, it fetches remote entries newer than the watermark and applies them locally.

Conflict resolution uses last-writer-wins with a special case for deletes:

if (row.operation === 'delete' && localEntry) {
  await table.delete(row.entity_id); // Delete always wins
} else if (localEntry && localEntry.timestamp >= row.timestamp) {
  continue; // Local is newer, skip remote
} else {
  await table.put(entity); // Apply remote entry
}

This is a deliberate trade-off worth naming. Last-writer-wins is simple and predictable, but concurrent edits from two devices will produce a winner and a loser. For a personal finance app used primarily on one device at a time, this is exactly the right call. CRDTs or operational transforms would add enormous complexity for a conflict profile that almost never occurs in practice.

Layer 5: End-to-End Encryption with Web Crypto API

The encrypted storage mode goes further: payloads are encrypted client-side before they ever reach Supabase. The server stores opaque ciphertext. Even a full database breach yields nothing useful.

The implementation uses only the browser’s native Web Crypto API, no external cryptography libraries:

export async function deriveKey(
  password: string,
  salt: Uint8Array,
): Promise<CryptoKey> {
  const encoder = new TextEncoder();
  const keyMaterial = await crypto.subtle.importKey(
    'raw',
    encoder.encode(password),
    'PBKDF2',
    false,
    ['deriveKey'],
  );
  return crypto.subtle.deriveKey(
    {
      name: 'PBKDF2',
      salt,
      iterations: 600_000, // OWASP recommended minimum for SHA-256
      hash: 'SHA-256',
    },
    keyMaterial,
    { name: 'AES-GCM', length: 256 },
    false,
    ['encrypt', 'decrypt'],
  );
}

The encrypted payload structure:

export interface EncryptedPayload {
  iv: string;         // Base64-encoded random IV (unique per encryption)
  ciphertext: string; // Base64-encoded AES-GCM ciphertext (includes auth tag)
  salt: string;       // Base64-encoded salt for key derivation
}

Four design decisions anchor this layer:

600,000 PBKDF2 iterations. OWASP’s current recommendation for PBKDF2-SHA-256. This makes brute-force attacks on the password computationally expensive. Key derivation takes a noticeable moment on first login. We accept that cost.

AES-GCM, not AES-CBC. GCM provides authenticated encryption, decryption verifies the ciphertext has not been tampered with. If an attacker modifies stored data, decryption fails loudly rather than silently producing garbage. This matters when untrusted network paths are involved.

No external crypto libraries. The Web Crypto API ships in every modern browser, is implemented in C++ rather than JavaScript, and carries zero supply-chain risk. Depending on crypto-js for security-critical code adds unnecessary attack surface.

“Bring Your Own Supabase.” The user provides their own Supabase project URL and anon key. Talliofi never touches a server we control. The user owns the entire backend. This is the strongest possible privacy guarantee short of no sync at all.

The UX Result

The architecture produces a specific, demonstrable user experience:

• First load: Fully functional within 200ms. No API call required.
• Offline use: Identical to online use. Adding, editing, deleting data, rendering reports — all local.
• Return after absence: Open the app after a week and see your data instantly, then sync in the background if enabled.
• No account, no friction: New users start planning immediately. Onboarding never asks for an email address.

This experience is only possible because IndexedDB is the source of truth and the network is a sync layer, not a dependency.

What This Architecture Costs

No free lunch. Local-first has real trade-offs, and pretending otherwise would be dishonest.

Storage is bounded. IndexedDB limits vary by browser and device. For a personal finance app with text-based records, this is not a practical concern, years of expenses fit in a few megabytes. Receipt images are a different story. Talliofi stores attachments as base64, which works but is inefficient. A blob-storage backend would be cleaner.

Sync conflicts are possible. Two devices editing the same expense simultaneously will resolve by timestamp. Most users will never notice. Power users who genuinely edit from two devices at once will occasionally see a stale value overwritten. The app surfaces sync status but does not expose conflict details to the user.

Testing is more complex. Code that writes to IndexedDB requires a DOM-capable test environment. Vitest with jsdom handles this, but setup is more involved than mocking a fetch call. The repo abstraction helps, unit tests inject a mock repo, integration tests hit a real in-memory IndexedDB instance.

Migration is manual. Schema migrations in Dexie are code, not SQL. Version 9 has 9 sequential migration steps. Manageable today, but it demands discipline as the schema evolves.

Why This Pattern Scales

The three-mode architecture earns its complexity when you see what it enables for free:

• Full offline support: Already there. No extra code needed.
• Export/import: Read from Dexie, serialize to JSON/CSV. Works offline.
• Multi-plan scenarios: Each plan is an isolated namespace in IndexedDB. Switching plans is instant.
• Multi-currency: Exchange rates cached locally. Currency conversion works offline with last-known rates.
• Encryption: Wraps the existing Supabase layer. The Dexie layer stays untouched.

Every feature that reads or writes data gets offline support automatically because IndexedDB is always the first stop. The sync engine handles getting changes to the cloud eventually. Features ship faster because the hard problem, “where does the data live?”, is already solved.

Start Here

If you are building a web app where data privacy matters, the local-first model is worth the investment. The core pattern is five layers deep, but each layer is straightforward on its own:

1. IndexedDB (via Dexie) as the source of truth — not the server.
2. TanStack Query as a cache — with query functions that read from IndexedDB, not fetch from APIs.
3. A repo interface — implemented by both a local Dexie repo and a remote sync repo.
4. A routing function — that selects the right repo based on user preference.
5. A sync engine — that runs in the background, never in the critical path.

The user gets privacy by default and cloud sync as a deliberate choice. That is a better deal than most apps offer. And it is achievable with standard web platform APIs — no proprietary infrastructure, no vendor lock-in, no trust required.

Your data, on your device, on your terms. That should not be a radical idea. But until more apps are built this way, it still is.

Visit Talliofi Website

It is Friday at 5pm and you are pretending to care about that last Slack message.

But your brain is already somewhere else.

You have been thinking about that side project all week. The one you scribble architecture for during standups. The one you “accidentally” have three tabs open for right now.

Here is something most people will never understand about you: you go home after a full day of building things, and then you build more things. For fun. On purpose.

That is not normal behavior. That is superhuman behavior.

You live in a world most people do not get. Some of your friends think “API” is a type of beer. Your family describes your job as “something with computers.” And yet here you are, halfway between machine learning papers and Stack Overflow at midnight, quietly building the future while everyone else is watching Netflix.

And if you are reading this right now thinking “I never finish anything” — relax. Most shipped products started as abandoned repos that someone came back to on a random Saturday because they could not sleep.

You are not behind. You are just loading.

The difference between a side project and a startup is about 3 weekends and one mass DM to your friends that says “hey can you test something for me, it will only take 2 minutes.”

It will not take 2 minutes.

Here is what I have learned watching hundreds of builders at hackathons, in Discord servers, and across dev communities: the ones who ship are not the most talented. They are the ones who start before they are ready and ask for help before they are stuck.

That is it. That is the whole playbook.

But let me say this clearly: the world needs you. Not in a corny motivational poster way. In a real way.

We are living through the biggest technology shift most people will ever see, and the majority of the population does not understand what is happening. You do. That makes you rare. Do not take that for granted, and do not shame anyone who has not caught up yet.

Bring them along. That is what superhumans do.

A lot of the weekend builders I talk to are deep into AI right now. Building agents, adding memory to chatbots, wiring up RAG pipelines, trying to make their apps actually remember context instead of starting from scratch every conversation.

That is exactly why we built Backboard. It is the infrastructure layer for AI apps — memory, state management, model routing, RAG, tool calls — all through one API. No stitching five tools together. No losing your conversation history every time you swap models.

Here is the weekend deal: sign up and you get free state management for life plus free dev credits to play with. No catch. No trial that expires on a Tuesday when you forgot to cancel. Just go build something, break something, and let us know what you think.

We built this for weekend builders. Your feedback is literally how we get better.

So this weekend, if you ship something, tag me. If you break something, tag me faster. And if you spend the whole weekend staring at your IDE with a blank file open, just know — that is also part of the process.

Have fun this weekend, super devs. See you on the other side of Sunday.