Articles
On code, AI, security and market fit — things worth knowing before the users arrive.
-
Error Handling Basics: Why Apps Break Silently
Error handling explained simply: why apps fail silently, what to do with errors on the frontend and backend, and what to show users versus what to log.
-
What Production-Ready Actually Means: A Definition
Production-ready isn't a feeling. It's six properties you can check: security, data safety, observability, recoverability, performance and maintainability.
-
Launching on Product Hunt: what it gives you and what it doesn't
What to expect from launching on Product Hunt and similar sites, how to prepare the product, and what to do the day after the spike ends.
-
Dark mode without the pain
Layered surfaces instead of pure black, text contrast, separate accent and status colors, and the tokens without which dark mode can't be maintained.
-
Choosing a model for the task: quality, speed, cost
What you trade off when picking a model, how to test the smaller tier on your own data, how to measure latency and how not to get locked in.
-
How to Speed Up a Web App: Quick Wins for Young Products
How to speed up a web app without a rewrite: images, database indexes, caching, fewer requests and lazy loading, plus how to measure before and after.
-
Technical due diligence before an investment: how to prepare
What investors look at in technical due diligence, which findings turn into red flags, and which documents to put together in advance.
-
Environment Variables: Where Settings and Secrets Live
What environment variables are, why you need a .env file, why values differ between development and production, and why secrets never go in the frontend.
-
Your first B2B customers: founder-led sales, design partners and pilots
Why founders make the first B2B sales, how to work with design partners, and how to run a pilot that ends in a contract instead of silence.
-
Accessibility: the minimum worth doing now
Contrast, visible focus, field labels and keyboard support: a baseline level of accessibility in a couple of days, and why it helps every user.
-
UX for AI features: waiting, errors and trust
How to handle waiting and streaming, what to do with errors, why results must be easy to edit and which signals help people trust an answer.
-
When everything is down: a simple incident playbook
One page written in advance: who decides, where to talk, what to do first, how to update users, and how to review an outage without hunting for culprits.
-
Dependency hygiene: lockfiles, abandoned packages and an update rhythm
Keeping dependencies under control: reproducible builds, choosing packages, supply-chain basics and a calm cadence for updates.
-
Domain, DNS and SSL Explained: How Browsers Find Your Site
Domain, DNS and SSL explained simply: how a browser turns a name into a server, what A records and CNAMEs do, why changes take time and what the padlock means.
-
Your first acquisition channel: where to look and how long to wait
How to pick a first channel based on where users already look for a solution, run it on its own, and decide in advance when to call the result.
-
The pricing page: plans, anchors and honesty about limits
How many plans to show, how anchoring works, why limits need actual numbers, and which questions to answer under the plans so people click.
-
User data and AI providers: what you are actually sending
What goes to the model provider with every request, which retention settings to check, when you need consent and how to strip what isn't needed.
-
Logs without personal data
What to log, what to mask, how long to keep it, and how a request ID lets you debug problems without knowing who the user was.
-
File uploads without surprises
Size and type checks, storage, public versus private links, malicious files and image processing: what to settle before the first upload.
-
Refactor or rewrite: deciding on evidence, not mood
Which signs point to a rewrite, which to refactoring, how to gather them in a week, and why the hybrid option usually wins.
-
How to hire a developer to finish your vibe-coded MVP
How to hire a developer to finish an MVP built with vibe coding: what to prepare, how to scope, a paid audit first, red flags, fixed vs hourly.
-
What Is Deployment? From Your Laptop to a Live URL
What is deployment, in plain terms: builds, servers, serverless and rollbacks, and how your app gets from your laptop to an address real people can open.
-
A tracking plan: events that answer questions
How to build an analytics tracking plan from questions rather than buttons: event names, properties, where to send them from, and avoiding event soup.
-
Why your interface looks like a template, and how to make it yours
Where the I've-seen-this-before feeling comes from and how to lose it without a rebrand: hierarchy, type, restrained color and your own copy.
-
Agent or a single call: how much autonomy you actually need
When one model call is enough, when a fixed chain of steps is better, when you really need an agent, and what its freedom costs you.
-
The first thousand users: what breaks first
Not the server and not the load, but queries in loops, missing indexes, heavy work inside requests and email limits. How to find them early.
-
How to review AI-generated code
What to look at in changes from an assistant, which signs should worry you, and how to keep review from becoming a formality.
-
Technical debt in a vibe-coded app: see it, size it, pay it down
How to find the debt that actually slows you down, put it in terms people understand, and pay it off without stopping feature work.
-
Moving your project out of Lovable, Bolt or Replit
What to export, what breaks on the way, and the order to move code, database, files and domain so your users never notice.
-
Authentication vs Authorization: Who You Are vs What You May Do
Authentication vs authorization explained: who you are versus what you may do, and why data in vibe-coded apps usually leaks through the second one.
-
Retention: which metrics to watch and which to ignore
Cohorts, activation and usage frequency: what to measure to know whether people come back, and which pretty numbers only distract you.
-
Mobile mistakes you notice on the first tap
Tiny tap targets, keyboards covering fields, sticky headers, wide tables and hover that doesn't exist: what to check in your mobile version.
-
How to check model output quality instead of taking it on faith
A small set of test cases, automated graders and a regression run before every prompt change, so a fix in one place doesn't break another.
-
Database migrations without downtime: expand, migrate, contract
Why renaming a column can take production down, how expand/contract works, how to backfill in batches, and what to do instead of rolling back.
-
Which tests to write first, and which can wait
In a young product, tests belong where a bug costs money, access or data. Everything else can wait without guilt.
-
Project Documentation: The README and Handover Minimum
Project documentation without the bloat: what a README needs so another developer or agency can take over: setup, env vars, architecture, deploy, gotchas.
-
Bugs in AI-Generated Code: Ten Common Ones and How to Spot Them
Ten common bugs in AI-generated code: hard-coded secrets, missing auth checks, silent failures, race conditions, N+1 and more, and how to spot each.
-
Git for Vibe Coders: The Minimum That Saves a Project
Git for vibe coders: commits, branches, how to undo a broken change, why you want GitHub, and why secrets must never be committed. The bare minimum, explained.
-
In-app purchases and subscriptions done right
In-app purchases and subscriptions in a mobile app: store rules, server-side receipt validation, restoring purchases and the common mistakes.
-
How to test your price while the product is still rough
Anchors, fake doors, talking money in interviews and raising prices for new users: cheap ways to find out what your product is worth.
-
A do-it-yourself UX audit
How to walk your key flows as a newcomer, run a five-person test, what to write down along the way, and in what order to fix what you find.
-
RAG without the hype: when it helps and how not to break retrieval
When searching your own documents before the model answers actually helps, how to chunk text, test retrieval and cite the source.
-
Monitoring an early product: four signals and some quiet
The minimum set of uptime, errors, latency and background queue depth, plus rules that make alerts wake people only when it matters.
-
Payments without double charges: webhooks, signatures and reconciliation
How to handle payment webhooks so retries, races and missed events don't turn into double charges and lost orders.
-
Naming Conventions in Code: Why Names Matter More
Naming conventions decide whether people and AI assistants can understand your code. Why bad names are expensive, and practical naming rules that hold up.
-
How to vibe-code without having to rewrite it all later
Small steps, a commit after every working state, tests, reading the diff and a rules file: habits that let a prototype grow into a product.
-
What Is Refactoring, and How to Do It Without Breaking Things
What is refactoring? Changing how code is structured without changing what it does. What it isn't, why it pays off, and how to do it safely in a real app.
-
Push notifications: how they work and what to send
Push notifications in plain words: how APNs and FCM work, when to ask for permission, what to send, what to skip, and how to measure the effect.
-
Early-stage positioning: one sentence that does the work
How to answer three questions, for whom, instead of what and why now, and fit the answer into one sentence that works without you in the room.
-
A design system for a small team
Tokens, a dozen components, well-defined states and a few habits that keep design and code in sync, without a hundred pages of documentation.
-
Structured outputs instead of parsing free text
Why you shouldn't scrape data out of model replies with regexes, how to define a schema, validate the result and what to do when validation fails.
-
Backups you can actually restore from
What to back up besides the database, how long to keep it, where to store copies, and how to run drills so a restore stops being improvised.
-
Sign-in and sessions: where AI-generated auth goes wrong
Tokens in localStorage or cookies, sessions that never expire, leaky password resets, and permission checks that only exist in the UI.
-
Dead Code and Duplicates: How to Remove Them Safely
What dead code is, why vibe-coded apps collect so much of it, and how to remove it safely using usage search, tooling, logs, feature flags and small commits.
-
The Limits of Vibe Coding: Where It Stops Working
The limits of vibe coding show up in complex state, security, scale, integrations and maintenance. Where the line is and how to tell you've hit it.
-
What Is an API, and Why Your API Key Is a Wallet Key
What is an API? How programs ask each other for data and actions, why an API key works like a key to your wallet, and how public and secret keys differ.
-
App Store rejection: why it happens and how to fix it
Got an App Store rejection for an app built with AI tools? The usual causes: crashes, placeholders, privacy gaps, login walls and purchase rules.
-
The concierge MVP: do it by hand before you write code
Why it pays to deliver the service manually first, what that teaches you, and how to tell which part of the process is ready to automate.
-
Forms people actually finish
Cut fields, validate at the right moment, write errors in plain language and stop fighting autofill: a step-by-step look at forms.
-
Prompt injection in plain words
What direct and indirect prompt injection are, what they can actually do, and why the defense has to be layered rather than one line in the prompt.
-
Dev, staging, production: three environments and how not to mix them up
How to keep config apart, stop a test key reaching production and a live key reaching a laptop, and where staging data should come from.
-
Where to keep API keys and secrets so you never rotate in a panic
Environment variables, secret managers, rotation, and the short list of places a key should never end up.
-
Project Structure: How to Organise Files and Folders
Project structure in plain terms: feature folders vs layers, and where config, UI, logic and data access should live so neither you nor the AI gets lost.
-
Vibe Coding for Founders: Build an MVP Without Getting Stuck
Vibe coding for founders without a technical background: how to build an MVP yourself, what not to do alone and when to bring in engineers.
-
Frontend and Backend, Plus the Database, Explained Simply
Frontend and backend explained simply: what an app is made of and what happens when a user taps a button, followed step by step through one real request.
-
How to publish an app to the App Store and Google Play
How to publish an app to the App Store and Google Play: developer accounts, code signing, test builds, store listing, review and updates.
-
How to talk to customers so they don't lie to you
Customer interviews without polite fiction: ask about the past, don't pitch, and write down facts instead of impressions.
-
Empty states, the first screen a new user actually sees
Why "No data" doesn't cut it, what belongs on an empty screen, and how first run, empty search, all done and failed loading differ.
-
Why your LLM bill grows faster than revenue, and how to cap it
Per-user and daily caps, caching, the right model per task, retries with backoff and token logging per feature, so the month-end bill holds no surprises.
-
CI/CD for a small team: the minimum that pays off
Which checks to run on every push, which tests to write first, why branches deserve preview deploys, and why production should ship on a button.
-
Row Level Security in Supabase: actually closing your tables
How RLS policies work, where they most often go wrong, and how to prove that other users' rows are really out of reach.
-
Your First Week With an Inherited Messy Codebase
How to get your bearings in an inherited messy codebase without breaking production: run it locally, map it, find what's actually used, ship one safe change.
-
Vibe Coding Prompts That Don't Turn Your Project Into Chaos
Vibe coding prompts that keep a project under control: give context, work in small steps, set limits, ask for a plan first and check every result.
-
What Is an MVP, Really (and What It Isn't)
What is an MVP? The smallest thing that tests your riskiest assumption with real people. How an MVP differs from a prototype and a v1, and common mistakes.
-
PWA vs native app: what to choose for your MVP
PWA vs native app, or React Native and Flutter in between: what to choose for an MVP, where each option hits its ceiling and when to switch.
-
Market fit before marketing
Why paid traffic won't save a product without retention, how to spot early signs of market fit, and which cheap experiments to run first.
-
Onboarding that makes people stay
How to shorten the path from signup to first value: fewer fields up front, setup when it's needed, and hints at the right moment.
-
Designing an AI feature: start from the job, not the model
Start from what the person is trying to get done, define failure up front, and keep a path to a human for when the model falls short.
-
Vercel, your own server, or a big cloud: where to host an early product
How platforms, VPSs and clouds like AWS differ, where vendor lock-in really comes from, and how to think about costs before the first big bill.
-
A pre-launch checklist for a vibe-coded app
Eight checks before real users arrive: secrets, data access, validation, rate limits, backups, alerts, payment webhooks and environments.
-
How to Clean Up a Vibe-Coded App: A Two-Week Plan
How to clean up a vibe-coded app in two weeks: inventory, secrets, access, structure, tests on money flows, deployment and docs, day by day, no rewrite.
-
Vibe Coding Tools Compared: Lovable, Bolt, Cursor and More
Vibe coding tools come in three kinds: browser builders, AI editors and agents. How Lovable, Bolt, Replit, v0, Cursor and Claude Code differ.
-
What Is Vibe Coding? Who It Suits and What It's Good At
Vibe coding means AI writes the code while you describe what you want in plain words. Who it suits, what it does well and where it starts to break.
Want us to do this for you?
Tell our assistant about your project — a rough estimate in five minutes, a review in 48 hours.