<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by tomozilla on Medium]]></title>
        <description><![CDATA[Stories by tomozilla on Medium]]></description>
        <link>https://medium.com/@tomozilla?source=rss-2e2d9e39db75------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jKIH9pv0zA06_HxPjlMS-A.png</url>
            <title>Stories by tomozilla on Medium</title>
            <link>https://medium.com/@tomozilla?source=rss-2e2d9e39db75------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 09:17:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tomozilla/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Where Did My Database Change Go?]]></title>
            <link>https://medium.com/@tomozilla/where-did-my-database-change-go-b6127c51d676?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6127c51d676</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 06:12:42 GMT</pubDate>
            <atom:updated>2026-11-04T06:12:42.696Z</atom:updated>
            <content:encoded><![CDATA[<p><em>For people who build business apps with AI help: why changes should live in files, why a rehearsal stage changes when you find out about failures, and the one thing that surprised me most.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ufnVB444Q8rN9WrJBtvRw.png" /></figure><p>“Did that change actually go live?” Nobody on my small team could answer, and I was the one who had made it.</p><blockquote><strong><em>How this was made:</em></strong><em> I wrote this with Claude’s help: it drafted, and I ran the experiments, edited the text, and checked the results. The mistakes are mine.</em></blockquote><p>This article names no products, because the ideas apply to most services. A hands-on version, with steps and costs, is on Dev.to: <a href="https://dev.to/tomozilla/deploy-supabase-migrations-by-merging-a-pull-request-25mp">https://dev.to/tomozilla/deploy-supabase-migrations-by-merging-a-pull-request-25mp</a></p><h3>A change in your head can’t be traced</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HI9pKYuNnoylrOI3ZwuP_Q.png" /></figure><p>Think of a family recipe. “A bit more salt.” “Less sugar since last year.” Ask who changed what, and when, and nobody knows. The next cook has no idea why it tastes the way it does.</p><p>Changing the shape of an app’s database by clicking around works the same way. A message in chat says “fixed it.” Weeks later you want to undo it, and there is no record of what “it” was.</p><h3>Write each change as a numbered file</h3><p>The fix I settled on is small: put every change in its own file and number the files. The numbers give the order, like boxes in a move labelled 1, 2, 3. You can’t unpack box 4 before box 3.</p><p>A new teammate can now read the files from the top and see why the system looks the way it does. Nobody has to remember anything.</p><h3>Find the failure before it ships, not after</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gmw138L8oMQkBoo788bzeQ.png" /></figure><p>This is the part that surprised me most. A theatre rehearses before opening night, so the mistakes happen without an audience.</p><p>Shipping changes can have a rehearsal stage too: a throwaway copy where the new change runs first. In my test:</p><ul><li><strong>Without a rehearsal stage,</strong> a deliberately broken change went to production and I learned it had failed afterwards.</li><li><strong>With one,</strong> the same broken change was flagged on the review screen, before anything shipped, with the cause in plain text.</li></ul><p>Same failure, different moment of discovery.</p><p>The catch is money. In my setup the rehearsal stage was a paid feature billed by the hour. My short test came to cents at the published rate (about $0.013 an hour for the smallest size), but I did not check an invoice, and the usage was not covered by the spending limit. Delete the rehearsal copy when you finish.</p><h3>One stuck step blocks the rest</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mLO_dFbBE_Ojy1TkK-nv_w.png" /></figure><p>Because changes run in order, a broken one stops everything behind it. Picture a supermarket checkout: when the first customer’s payment hangs, the people behind them wait through no fault of their own.</p><p>I shipped a correct change and got the same old error as before. For a moment I thought my new change was the problem. The one to fix was the stuck step. Once it was fixed, everything behind it went through together.</p><h3>Not everything ships by itself</h3><p>A moving company carries the furniture. It won’t tell the neighbours or set up your electricity.</p><p>In my test, automatic shipping carried the database structure and small background programs. It did not carry a setting I had changed in the control panel, even after I wrote that setting into a file. If you assume “if it’s in the file, it’s live,” you won’t notice the setting that isn’t.</p><h3>What it costs</h3><ul><li><strong>Files plus automatic shipping:</strong> free in my run.</li><li><strong>The rehearsal stage:</strong> usually paid, billed for the hours it exists, and possibly outside your spending limit. Try it, then delete it.</li><li><strong>Effort:</strong> a little setup. I got stuck a few times. After that, the routine is: write the change as a file, check it, ship it.</li></ul><h3>Three things to try this week</h3><ol><li>Pick your last three changes and see if you can say who made each one, when, and what it was.</li><li>If you can’t, put the next change in a numbered file.</li><li>Ask whether anything lets you try that change before it hits the real thing.</li></ol><h3>In short</h3><ul><li>Changes in someone’s head can’t be traced. Write them as ordered files.</li><li>When you find a failure matters: a rehearsal stage moves it before the ship.</li><li>In an ordered pipeline, one stuck step blocks the rest. Fix that one.</li><li>Check what is shipped and what is not.</li><li>Rehearsal stages are usually paid. Delete them when done.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6127c51d676" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Many People Can Your App Serve at Once?]]></title>
            <link>https://medium.com/@tomozilla/how-many-people-can-your-app-serve-at-once-a7f0cb1df4d4?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7f0cb1df4d4</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 06:12:15 GMT</pubDate>
            <atom:updated>2026-11-04T06:12:15.802Z</atom:updated>
            <content:encoded><![CDATA[<p><em>For people building business apps with AI help: why “it worked in testing” says little about launch day, why connection limits multiply instead of adding up, and what I found by pushing a test setup past its limits on my own laptop.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vUQVbJ-vPZMA_NQnxcEXNw.png" /></figure><p>The day before a campaign, someone asked me: “Traffic could be ten times normal. Will the app hold?” I built the app. I couldn’t answer.</p><blockquote><strong><em>How this was made:</em></strong><em> I wrote this with Claude’s help: it drafted, and I ran every experiment, edited the text, and checked the results. The mistakes are mine.</em></blockquote><p>I name no products here, because the ideas apply to most services. The most serious thing I found is about safety, not capacity: <strong>a note left on a shared seat showed one guest another guest’s orders, and even the manager’s privileges</strong> (see “A note left on the seat”). A hands-on version with the scripts and the numbers is on Dev.to: <a href="https://dev.to/tomozilla/supabase-connection-budgets-pool-size-roles-modes-and-limits-4lc8">https://dev.to/tomozilla/supabase-connection-budgets-pool-size-roles-modes-and-limits-4lc8</a></p><h3>The database has a number of seats</h3><p>Behind your app sits a place where the data lives. Only so many callers can talk to it at the same moment. Think of seats in a restaurant: with 60 seats, guest 61 stands outside.</p><p>Here is the whole map, once. Everything below is somewhere in this picture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2nDXaHOrA6wOaOwJ-8Siog.png" /></figure><p>The band along the bottom is what I kept forgetting: <strong>even with no guests at all, the house’s own desks — the order desk, the membership check, the storeroom, the patrol — are each sitting in seats.</strong></p><p>The first surprise is that the number of seats you need isn’t set by the number of guests. It is set by <strong>how each guest uses a seat</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_f65QI4cxdpndOc_XOzdQw.png" /></figure><ul><li><strong>A reserved seat for everyone</strong> (kept even when idle): 100 guests, 100 seats.</li><li><strong>A host who rotates seats</strong> (you sit only while eating): 100 guests can share 15 seats.</li><li><strong>Staff who order for you:</strong> no seat of your own.</li></ul><p>The tools you build with have their own defaults. I counted the seats a handful of common tools take. One takes 10. One takes 21 on my laptop, because its default comes from the number of processor cores; its newer version takes 10, and, I found, it also lost its old rule of giving up after 10 seconds of waiting: the newer version waits forever unless you set a limit. One takes a seat for every busy guest. One takes a fixed four. So “which tool takes how many” has a date on it: it changes with the version.</p><h3>Seats are held per company and per entrance</h3><p>This was my biggest surprise, and I only found it because I couldn’t explain a number.</p><p>The host reserves seats <strong>per company</strong>, per entrance. Company A gets up to 15 seats, Company B gets up to 15, Company C gets up to 15. The phone-order desk and the house staff hold seats too. The house has 60. Add the staff (about 5) and the phone-order desk (about 11), and A and B fit: 46 seats. <strong>Company C arrives and the total is 61.</strong> Over.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pAoXZAFlAgWv8WMhv_-psw.png" /></figure><p>Each company, on its own, looks safe. “Only 15 seats.” The trouble is that the numbers <strong>multiply</strong>. I had been adding.</p><p>Two details made it tighter. In my tests the host held <strong>one seat more than the number I had set</strong> (16 for a limit of 15; I can’t explain why, and I saw it again on a live service with the limit set to 3). And <strong>3 of the 60 seats are kept for the manager</strong> and are not available to guests, so the real number was 57.</p><h3>When the house is full, “new” things stop first</h3><p>When the house is full, it isn’t only Company C that suffers. Here is what I saw:</p><ul><li>new guests couldn’t get in,</li><li>the check at the door (“are you on the guest list?”) failed, because that check needs a seat too,</li><li><strong>sign-in was the first thing to break, in my test.</strong> The sign-in desk keeps no seat of its own; it borrows one for each request and gives it back. With the house full, there was nothing to borrow. The rule is not “sign-in goes first” but “whatever has to ask for a new seat goes first”; a different desk would have been first if it had been the one without a spare seat,</li><li>the desks that already held seats (phone orders, the storeroom) kept working, as long as the seats they had were enough.</li></ul><p>I had to correct myself here. “Sign-in breaks first” was true <strong>of my own test setup</strong>, and I had quietly assumed it was a rule. When I measured a live service properly, it looked different. While nothing is happening, neither desk holds a seat. But:</p><ul><li>desk: membership check (sign-in); idle: 0 seats; right after a rush: <strong>about 10 seats</strong>; later: gave them back within about a minute</li><li>desk: the storeroom (files); idle: 0 seats; right after a rush: <strong>8 seats</strong>; later: still holding them 14 minutes later</li></ul><p>So a real sign-in desk <strong>keeps about ten seats warm</strong> once it has been busy. It will not necessarily be the first thing to fall over; it has ten seats in hand to work with.</p><p>What survives is the shape, not the order: <strong>whatever has to ask for a new seat at that moment is what stops.</strong> Which desk that is depends on your setup.</p><p>The storeroom is the one to write down. It took 8 seats and kept them. Out of 57 usable seats, that is 8 gone for good the first time someone opens a file. Count the house’s own desks <em>before</em> you count your guests.</p><p>So the symptom looks odd: the app works, but new people can’t sign in. And after the heavy guests had left, sign-in stayed broken for <strong>about a minute</strong>, because seats don’t free up instantly.</p><h3>Wait, or turn away?</h3><p>When seats run out, a restaurant either puts you in line or says “we’re full.” In my tests, <strong>the same system did both</strong>, depending on which entrance I used:</p><ul><li>One entrance made guests wait, and gave up on them after <strong>60 seconds</strong>.</li><li>One turned extra guests away immediately.</li><li>One desk gave up after <strong>10 seconds</strong>.</li></ul><p>And often there was no error at all. Things just got slower.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j7SQBrXcqMV8VypExcwiOQ.png" /></figure><p>I measured a job that takes a tenth of a second, served by 16 seats. Going from 5 guests to 100 changed <strong>nothing</strong> about how many jobs finished per second. It only changed the wait: a tenth of a second became six tenths. One line is worth remembering:</p><blockquote><strong><em>Seats busy at once = guests per second × seconds each guest stays</em></strong></blockquote><p>100 guests a second, each staying 0.2 seconds, needs 20 seats. With 15 seats a line forms, and nobody reports an error. So watch the <strong>spread of waiting times</strong> (the slow end), not only the error count.</p><p>The same line gave me a <strong>prediction</strong>: with 199 guests and 16 seats, once each guest stays more than about 5 seconds, the wait should reach the 60-second limit. At 4.5 seconds nobody was turned away. At 5.5 seconds, 46 guests were. It matched.</p><p>Guests who keep arriving at a steady rate are harder than guests who come back when they are done. At 200 arrivals a second against about 150 a second of capacity, the wait went from a quarter of a second to over a second in four seconds, and then about one in four arrivals was turned away at the door.</p><h3>A note left on the seat</h3><p>This one is about safety rather than capacity.</p><p>When the host rotates seats, the previous guest’s <strong>note</strong> can still be on the seat. In my test, a note like “this order belongs to Alice” was still there for the next guest <strong>8 times out of 8</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uFLWT1G9_c7Ph4yt1zrxHw.png" /></figure><p>It can be worse than a wrong order. If your app passes “who is asking” along as a note, the next guest who forgot to set one <strong>saw Alice’s rows</strong>. A note that says “treat me as the manager” stayed, and the next ordinary guest was treated as the manager. A note that removed the two-second limit on an order removed the limit for the next guest too.</p><p>The fix I found: use a note that is valid <strong>only while the guest is seated</strong> and is thrown away when they stand up. With that, the note didn’t stay. (A guest who talks to the staff directly, with no seat sharing, never left a note behind.)</p><h3>Stopping one company from taking over</h3><p>One heavy company can starve everyone. I tried three guardrails:</p><ul><li><strong>A seat cap per company.</strong> Past the cap, orders were refused at once, not queued, and the other companies were unaffected. Set the cap one above the number of seats the host hands out to that company; at exactly that number, guests who could have waited were turned away instead.</li><li><strong>A time limit per order.</strong> It worked, but a guest could ask for the limit to be removed, and then the next guest had none either. The backstop has to sit outside the guest’s reach: a staff member who checks every few seconds and ends any order that has run too long did stop the guest who had removed their own limit.</li><li><strong>A seat held back for the person who watches the house.</strong> With it, the watcher could still get in when the house was full. Without it, you can’t see why it is full.</li></ul><h3>The guest who sits and does nothing</h3><p>A guest who takes a seat and never orders keeps it. In an app, that is a job that started and never finished. The remedy is a house rule: “after a few seconds of doing nothing, you give up the seat.” With a 5-second rule, the seat was taken back after 5 seconds. Without one, one stuck job can hold a seat indefinitely.</p><h3>Seats don’t free up instantly</h3><p>When my test guests left, their seats stayed reserved for about <strong>two minutes</strong> — the same on my laptop and on a live service.</p><p>The published guidance says up to <strong>five minutes</strong>. My measurement was shorter, but when you plan, use the longer number: I measured one setup a handful of times. And the seating style that is documented as “freed the moment the guest leaves” wasn’t, in my test: that seat stayed over three minutes and was handed to the next guest.</p><p>A few short tests in a row can fill the house with nobody using it. When you plan, ask how long a seat stays taken after a guest leaves, not only how many guests are in the room.</p><h3>How I tested without hurting anyone</h3><p>Most of it ran on <strong>my own laptop</strong>, set to the same limits as a free plan, where I could break things freely. That is the safer way to find out what a full house looks like: not on equipment other customers share.</p><p>Then I checked a live service very gently: I turned its seat count down to <strong>three</strong>, used a handful of guests for a few seconds to a minute, and put the setting back afterwards. The per-company seats, the one extra seat and the 60-second limit were the same there. I also looked once, with no guests, at how many seats the live service’s own staff were using: 4 of 57.</p><p>For a few questions, a free setup simply cannot answer. How many seats does the sign-in desk hold when it is busy? Does paying for a bigger plan give you more seats? So I rented the smallest paid setup for about an hour and a half, ran small tests, and deleted it. That cost me about three cents.</p><p>What I did not do: I did not push a live service anywhere near its real limits, so the full-house behavior is “from my lab.” Each experiment ran a few times at most. I did not test several popular tools.</p><h3>What it costs</h3><ul><li>The whole thing cost me <strong>about $0.02</strong>. Nearly all of it ran on my laptop for free; the paid setup ran about an hour and a half and was deleted.</li><li>The question I most wanted answered was whether paying buys you seats. <strong>It doesn’t.</strong> I rented the smallest paid size and counted: the same 60 seats as the free one. Upgrading the plan alone adds no seats; a bigger <em>compute size</em> does (the next step up is 90), and it is billed by the hour. I haven’t seen a full month’s bill, so I can’t tell you what that adds up to.</li></ul><h3>What you can do this week</h3><ol><li><strong>Write down which tool opens how many connections</strong> (name and version). The number changes with the version.</li><li><strong>Multiply, don’t add:</strong> number of companies (or roles) × seats each, plus the system’s own, plus the held-back seats, compared with the total.</li><li><strong>Find out what happens when someone waits too long</strong>, once, in a test setup. How many seconds, and what does the user see?</li><li><strong>Check that “who is asking” can’t stay behind</strong> on a shared seat.</li></ol><h3>The short version</h3><ul><li>Seats depend on <strong>how</strong> guests use them, and on a tool’s defaults, which change with versions.</li><li>Seats are held <strong>per company and per entrance</strong>: multiply, don’t add. Count the extra seat and the manager’s seats. The queue outside the door is per company too — I tested it — but a longer queue buys no extra seats.</li><li>The house’s own desks take seats too, and some never give them back: in my measurements the sign-in desk took about ten and released them, the storeroom took eight and kept them.</li><li>When the house is full, <strong>whatever needs a new seat stops first</strong>. In my own test that was sign-in, but a real sign-in desk keeps seats warm, so don’t count on the order.</li><li>Waiting has a limit, and slow can look like “no errors.” Watch the slow end. The arithmetic can predict it.</li><li>Rotated seats can keep <strong>the last guest’s note</strong>, and that can leak rows and permissions. Use notes that vanish when the guest stands up.</li><li>A cap per company, an order time limit and a held-back seat for the watcher stop one guest from taking over.</li><li>Seats free up slowly: about two minutes in my tests, up to five by the published guidance. Plan for five.</li><li>A paid plan doesn’t mean more seats. I paid, and counted, and it was the same number.</li></ul><p>If you’ve been where I was the day before that campaign, I hope this saves you some of the guessing.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7f0cb1df4d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Having a Backup Isn’t the Same as Being Able to Restore]]></title>
            <link>https://medium.com/@tomozilla/having-a-backup-isnt-the-same-as-being-able-to-restore-f9c4c58ef3bd?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9c4c58ef3bd</guid>
            <category><![CDATA[database]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[data-backup]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Fri, 30 Oct 2026 04:32:49 GMT</pubDate>
            <atom:updated>2026-11-04T05:46:22.554Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A plain-English guide for people who build business apps: three things people call “backup”, the worst case you should know before something breaks, and a ten-minute drill that tells you whether it works.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vy5CgUix8a_jMHJXAkVyRw.png" /></figure><p>“We have backups, so we’re fine.” I believed that for a long time. Then I realised I had never tried to restore one.</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I ran the drill myself, checked the facts I could, and edited the text. The mistakes are mine.</em></blockquote><p>No product names here. The ideas apply to most cloud services.</p><h3>“Backup” means three different things</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g1vW7jaCfU77rtAv2xaeFg.png" /></figure><ol><li><strong>The nightly copy.</strong> You can go back to last night. Whatever changed since is not in it. Paid tiers usually include this.</li><li><strong>Rewind to a second ago.</strong> You can go back to just before a mistake. It is usually a separate paid option, with conditions such as a minimum machine size.</li><li><strong>Your own copy.</strong> You save it yourself, whenever you choose. This is the basic route on free tiers. If you forget, it doesn’t exist.</li></ol><p>Think of photos. The nightly copy is an automatic group photo every evening. The rewind is a video that never stops recording. Your own copy is a snapshot you take yourself.</p><h3>Ask “what is the worst case?”</h3><p>Instead of “do I have a backup?”, ask: <strong>if something went wrong right now, how far back would I be?</strong></p><ul><li>Your own copy: back to the last time you took one. If you never did, back to nothing.</li><li>The nightly copy: up to a day.</li><li>The rewind: a few minutes.</li></ul><p>Try one question with your team:</p><blockquote><em>If we lost everything since last night, would that be a problem?</em></blockquote><p>If not, the nightly copy may be enough. If yes, look at the rewind, and read its conditions and price before you rely on it.</p><h3>Some things are not in the backup</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ieZpCG2LLtkoLeokHDEOUA.png" /></figure><p>This surprised me. In some services, <strong>uploaded photos and files are not part of the database backup</strong>. The database keeps an index of which files exist, not the files. You can restore your records and still find the photos missing.</p><blockquote><em>“The data came back, but the pictures didn’t.”</em></blockquote><p>Some services also leave out certain passwords for safety. Ask where your files live and whether they are covered.</p><h3>Practise restoring</h3><p>This is the part that matters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Eap9NgaSynSX1G_CQ1VUMw.png" /></figure><ol><li><strong>Take</strong> a copy.</li><li><strong>Break</strong> something, in a practice environment: delete everything by accident.</li><li><strong>Restore</strong> from the copy.</li><li><strong>Count</strong>: do the rows and the total match the original?</li></ol><p>I did this with practice data. <strong>Five orders, $1,004</strong> became <strong>zero orders, $0</strong> after my “accident”, and came back to <strong>five and $1,004</strong> after the restore. It took a few minutes. The gap between “I think I can restore” and “I did” was bigger than I expected.</p><blockquote><em>“A backup exists” and “I restored it” are different things.</em></blockquote><p>One more lesson: <strong>you only get back to the moment the copy was taken.</strong> Anything saved after it is gone. How often you take copies decides how much you lose.</p><h3>Restoring takes the app offline</h3><p>In many services the app is <strong>unavailable while a restore runs</strong>, and the larger the data, the longer it takes. Decide in advance when you would do it and what you would tell customers.</p><h3>What it costs</h3><ul><li><strong>The nightly copy:</strong> usually part of the paid plan.</li><li><strong>The rewind:</strong> a separate fee that often grows with how many days you keep. It may also require a bigger machine.</li><li><strong>Your own copy:</strong> the work is free, but storing it somewhere safe may not be.</li></ul><p>The common misunderstanding is “backups are expensive.” People often mean the rewind, and mix it up with the nightly copy that is already included. Check which one a price refers to.</p><h3>What to do today</h3><ol><li>Find out which of the three you actually have.</li><li>Ask: “If we lost everything since last night?”</li><li>Run the drill once, with practice data.</li></ol><h3>The short version</h3><ul><li><strong>Three kinds:</strong> nightly copy, rewind, your own copy.</li><li>Choose by the <strong>worst case</strong>: how far back would you be?</li><li><strong>Files may not be in the backup.</strong></li><li>“I have a backup” is not “I restored it”. <strong>Practise, count, confirm.</strong></li></ul><p>For the hands-on version, with the real drill, the plan details from the docs, and a small check page: <a href="https://dev.to/tomozilla/supabase-backups-and-point-in-time-recovery-what-each-plan-includes-what-it-costs-and-a-restore-48h7">https://dev.to/tomozilla/supabase-backups-and-point-in-time-recovery-what-each-plan-includes-what-it-costs-and-a-restore-48h7</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9c4c58ef3bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Who Did That?” Why Shared Logins Break Down]]></title>
            <link>https://medium.com/@tomozilla/who-did-that-why-shared-logins-break-down-and-what-to-put-in-their-place-125c58406e79?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/125c58406e79</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[authentication]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Fri, 30 Oct 2026 04:31:49 GMT</pubDate>
            <atom:updated>2026-11-04T05:48:40.335Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A plain-English guide for people who build business apps: why a shared password erases “who”, how to keep a log that people can’t rewrite, and why the log is not the same as protection.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KqlzcUZe9i3WDjsdRiTGzQ.png" /></figure><p>“Who deleted this?” If your team shares one username and password, nobody can answer.</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I ran the experiments, checked the facts, and edited the text. The mistakes are mine.</em></blockquote><p>I started with a shared login myself, “just for a few of us”. Here is what I learned when I tried the alternative. No product names: the ideas apply to most services.</p><h3>A shared key erases “who”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1zYoSoLX6mpC1MJICeD-pQ.png" /></figure><p>Picture one office key that everyone copies. If something goes missing overnight, nobody knows who opened the door.</p><p>A shared login works the same way. You may have a log, but the same name appears on every line.</p><ul><li><strong>Who deleted it?</strong> You can’t tell.</li><li><strong>Someone left the company.</strong> To lock them out you change the password, which locks everyone out.</li></ul><p>With <strong>one login per person</strong>, the log carries their name, and you can stop just one person.</p><h3>Don’t let people write their own log</h3><p>How you record “who did what” matters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c65Grv9nEggLOnzbZhCjDw.png" /></figure><blockquote><strong><em>Keep the log out of reach of the people it records.</em></strong></blockquote><ul><li>If the <strong>screen</strong> writes the log, entries can be forgotten, edited, or sent with someone else’s name.</li><li>So let the <strong>data layer</strong> write it automatically. “Who” comes from the login, not from what the screen sends.</li><li>Make the log <strong>read-only</strong>: no edit, no delete.</li></ul><p>I tried this on practice data:</p><ul><li>Two people on a <strong>shared login</strong>: the log showed the <strong>same name twice</strong>.</li><li>Three actions with <strong>personal logins</strong>: the log showed <strong>each person’s name</strong>.</li><li>I then tried to write someone else’s name, edit the log, delete it, and add a fake entry. <strong>All of it was stopped.</strong> My attempt to name another person was silently replaced with my own name.</li></ul><h3>Two doors</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6hmTgQ5wt2XH1oGAz4Efcw.png" /></figure><p>“Who” is decided at two doors:</p><ul><li>The <strong>company’s door</strong>: who may enter the service’s admin console, with roles such as owner, admin and developer.</li><li>The <strong>app’s door</strong>: who may use your app: customers and staff.</li></ul><p>They are <strong>separate lists</strong>. Tightening the admin console does not give you a log of what users do inside your app.</p><h3>A log is after the fact</h3><blockquote><em>A log tells you </em><strong><em>later</em></strong><em>. It does not </em><strong><em>prevent</em></strong><em>.</em></blockquote><p>If everyone can change everything, you will know who did it afterwards, but the damage is done. Decide <strong>who may change what</strong> as well.</p><h3>Costs and chores</h3><ul><li>Many services limit the number of active users per month, then charge per extra user.</li><li>Logs <strong>grow forever</strong>. Decide how long to keep them and where old ones go.</li><li>Joiners and leavers need accounts added and stopped. That extra work is the price of knowing “who”.</li></ul><h3>What to do today</h3><ol><li>List the logins your team shares.</li><li>Replace <strong>one</strong> with personal logins.</li><li>Ask: “Could we answer ‘who deleted that?’”</li></ol><h3>The short version</h3><ul><li>A shared login erases “who”: <strong>one login per person</strong>.</li><li>Write the log in the <strong>data layer</strong>, where the people it records cannot reach it.</li><li>The console’s people and the app’s people are <strong>different lists</strong>.</li><li>A log is <strong>after the fact</strong>: also decide who may change what.</li></ul><p>For the hands-on version, with the real tables, triggers, a tamper drill and a small portal page: <a href="https://dev.to/tomozilla/per-user-logins-and-an-audit-trail-in-supabase-auth-rls-and-triggers-a-tamper-drill-and-a-small-4ndl">https://dev.to/tomozilla/per-user-logins-and-an-audit-trail-in-supabase-auth-rls-and-triggers-a-tamper-drill-and-a-small-4ndl</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=125c58406e79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Who Owns Your Customer’s Backend: You or Them?]]></title>
            <link>https://medium.com/@tomozilla/who-owns-the-customers-backend-two-ways-to-run-one-app-for-many-clients-yours-or-theirs-50275a612b87?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/50275a612b87</guid>
            <category><![CDATA[supabase]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 02:45:45 GMT</pubDate>
            <atom:updated>2026-11-04T05:45:13.894Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A plain-English guide for people who build business apps: the two ways to own a customer’s environment, why copies of the same blueprint drift, and the four checks before you hand one over.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vg8cWHriErVvplPDSq0VXw.png" /></figure><p>You built an app with AI help, and now every customer wants a space of their own, so nothing mixes with the next customer’s. You give each one a dedicated environment. A few months later come the new questions: why is this one different, who owns that one, and where does the bill go?</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I ran the experiments, checked the facts, and edited the text. The mistakes are mine.</em></blockquote><p>I ran into those questions myself, so here is how I think about them now. No product names. The idea fits most cloud services.</p><h3>Two owners</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JkYaE36CCnnT8l9lab3cyg.png" /></figure><ul><li><strong>A: you own it.</strong> Each customer’s “office” sits inside your company. The bill comes to you, and you manage and maintain everything.</li><li><strong>B: they own it.</strong> The office sits inside the customer’s company. The bill goes to them, and you are a guest with access.</li></ul><p>Think of an apartment building. In A, the property manager holds the lease on every unit. In B, each tenant signs their own lease, and the manager keeps a key for repairs.</p><p>Neither is right in general. Decide by asking: <strong>who should handle the contract and the operations?</strong></p><ul><li>The customer doesn’t want to deal with contracts: A.</li><li>The customer wants it under their own contract: B.</li><li>Start with A and hand it over later: often possible, with conditions.</li></ul><h3>The cost follows the owner</h3><ul><li>In <strong>A</strong>, each running environment adds to <strong>your</strong> monthly cost. Ten customers means ten environments.</li><li>In <strong>B</strong>, your cost does not grow. The customer pays.</li></ul><p>So in A, your fixed cost rises with the number of customers. Work out the cost <strong>per customer</strong> before you sign the contract.</p><h3>Copies drift apart</h3><p>You will want every customer’s environment built from one blueprint. At first they match. Then:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qfCrf-fT_I18julfeilYhw.png" /></figure><ul><li>Someone <strong>made a quick change</strong> for one customer, “just add one field.”</li><li>You updated the blueprint, but one environment <strong>stayed on the old version</strong>.</li></ul><p>Soon “all the same” is “all slightly different.”</p><p>The fix is to check “is this the same shape?” with <strong>one number</strong>, like a fingerprint: same shape gives the same value, any difference gives a different one. Compare <strong>the shape only</strong>, not the customer’s data. You never need to look inside.</p><h3>Before a hand-over</h3><p>Starting in A and moving to B later is a real path, but “it can be moved” is not “it can be handed over safely.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GKePC4wWw7H1athL5tiP_g.png" /></figure><ul><li>Can someone <strong>get into</strong> their company?</li><li>Are <strong>ties</strong> left attached (links to other tools, special roles, forwarding)?</li><li><strong>Where does the bill switch</strong>? Usually old company before the move, new company after.</li><li>What will <strong>your access</strong> be afterwards? Decide the support door in advance.</li></ul><h3>Keep a registry</h3><p>Once you have a dozen environments, you need a simple list:</p><p>That is enough to answer “which are old, who owns them, when did we look?” When someone takes over from you, this is the page they need most.</p><h3>What to do today</h3><ol><li>List every customer environment you have.</li><li>Mark each one A (yours) or B (theirs).</li><li>Work out the monthly cost for <strong>one</strong> customer.</li></ol><h3>The short version</h3><ul><li>Pick the owner by <strong>who handles contract and operations</strong>.</li><li>Cost grows with customers in A, not in B.</li><li>Copies of one blueprint <strong>drift</strong>. Check the shape with a fingerprint.</li><li>“Can be moved” is not “safe to hand over.”</li><li>A <strong>registry</strong> is the best hand-over tool.</li></ul><p>For the hands-on version, with a real template applied to two projects, a real fingerprint that caught a hand-made change, and a small console page: <a href="https://dev.to/tomozilla/one-supabase-project-per-customer-apply-a-template-catch-hand-made-changes-with-a-schema-301h">https://dev.to/tomozilla/one-supabase-project-per-customer-apply-a-template-catch-hand-made-changes-with-a-schema-301h</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50275a612b87" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Your Cloud Bill Surprised You]]></title>
            <link>https://medium.com/@tomozilla/why-your-cloud-bill-surprised-you-pay-as-you-go-explained-for-people-who-build-with-ai-fd38d7d84bb2?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd38d7d84bb2</guid>
            <category><![CDATA[cost-optimization]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[supabase]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 02:44:18 GMT</pubDate>
            <atom:updated>2026-11-04T05:44:05.464Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A plain-English guide: the three boxes inside every bill, what a “spending limit” really protects, and the one question to settle with your team before the first invoice.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6GbIrqgQY7QkeyEoTScZVg.png" /></figure><p>“The base fee was cheap. So why is the bill this high?” You built an app with AI help, a few people started using it, and the first real invoice felt wrong.</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I read the pricing pages and docs, checked the numbers I could, and edited the text. The mistakes are mine.</em></blockquote><p>I had the same reaction once, so I traced where the money goes. No product names here. The picture fits most cloud services that bill by usage.</p><h3>A bill is three boxes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sianj69EnZULckCSvVl-Xg.png" /></figure><ul><li><strong>Base fee.</strong> The price of the plan. Think of the fixed part of a phone contract.</li><li><strong>Machines running.</strong> The computers that run your app, charged by the hour. Closer to renting a car by the hour than to a flat fee.</li><li><strong>What you used.</strong> Users, traffic, storage. Like a water meter: you pay for the part past what is included.</li></ul><p>“The base fee was cheap” surprises happen in boxes two and three.</p><h3>Three ways bills balloon</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OHjjUtAIFmQ5KWz6xWVWuA.png" /></figure><ol><li><strong>A sudden rush.</strong> A post goes around, you run a promotion, and usage passes the included amount.</li><li><strong>A bigger machine.</strong> The app felt slow, so you upgraded. Hourly billing means a forgotten upgrade keeps adding up.</li><li><strong>An add-on.</strong> “Rewind to a second ago,” a custom domain. Each one is a new monthly line.</li></ol><h3>What does a “spending limit” protect?</h3><p>Many services have a switch that limits overspending. This is the part I understood least, so I read the docs closely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8LP7JZ7gDPpl7srnSv39Ww.png" /></figure><p>What I took away:</p><ul><li>It mostly protects <strong>usage</strong>: traffic, users, storage.</li><li>Past the allowance, <strong>the bill does not grow, but service can be limited or stop.</strong></li><li><strong>Machines and add-ons are usually charged either way.</strong></li></ul><p>So:</p><blockquote><strong><em>“The bill won’t grow” and “the service won’t stop” are different things.</em></strong></blockquote><p>Think of a water meter with a valve that closes at a set amount. Your bill stays flat, and the shower goes cold.</p><p>One more point. In the service I read about, the limit had <strong>no per-item budget and no alert</strong> when you got close. You have to go and look at the usage page yourself. Check how yours works.</p><h3>Decide this once, before the first invoice</h3><p>I would sit down with the team for ten minutes and settle three things:</p><ol><li><strong>Which hurts more: a stop or a bigger bill?</strong> A tool customers use every morning may prefer a bigger bill. An internal experiment can afford a stop.</li><li><strong>Who looks at usage, and when?</strong> “First Monday of the month” works.</li><li><strong>Before adding anything, write down the monthly cost.</strong> A bigger machine, an add-on: what does it add per month?</li></ol><h3>One calculation to do before you commit</h3><blockquote><em>If my users grew tenfold, what would the bill be?</em></blockquote><p>On paper: does the base stay the same, does usage grow, do I also need a bigger machine? Five minutes, and the answer is usually not a surprise anymore.</p><h3>If you pay late</h3><p>Many services pause your app when an invoice goes unpaid. Check your service’s rules and the payment method, once, before you rely on it.</p><h3>What to do today</h3><ol><li>Open your service’s usage page.</li><li>Ask the team: stop, or bigger bill?</li><li>Write down the “tenfold” number.</li></ol><h3>The short version</h3><ul><li>A bill is <strong>base fee, machines, usage</strong>.</li><li>A limit usually <strong>keeps the bill flat by stopping things</strong>, and does not cover machines or add-ons.</li><li>Many have <strong>no alerts</strong>. Go look.</li><li>Decide <strong>what hurts more</strong>, in advance.</li></ul><p>For the hands-on version, with real screens, the docs’ covered and not-covered lists, and a small simulator that shows the bill with the limit on and off: <a href="https://dev.to/tomozilla/read-your-supabase-bill-compute-usage-and-what-the-spend-cap-covers-and-doesnt-plus-a-small-4ml4">https://dev.to/tomozilla/read-your-supabase-bill-compute-usage-and-what-the-spend-cap-covers-and-doesnt-plus-a-small-4ml4</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd38d7d84bb2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One Account, Many Projects: How to Stay Organized]]></title>
            <link>https://medium.com/@tomozilla/one-account-many-projects-how-to-organize-departments-and-customers-without-losing-track-f19c78f2ba25?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/f19c78f2ba25</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[supabase]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 02:39:49 GMT</pubDate>
            <atom:updated>2026-11-04T05:42:55.194Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A plain-English guide for people who build business apps with AI: the company-and-offices picture, three ways to split things, and a once-a-year inventory that keeps the bill and the owners clear.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w9l-2GQdBT-_aIGri5PXng.png" /></figure><p>You build an app with AI help. It works, so you build another. A few months later someone asks, “Whose is this one? Is it still running? Who pays for it?” and nobody knows.</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I did the hands-on work, checked the facts, and edited the text. The mistakes are mine.</em></blockquote><p>I got stuck on that question once, so I wrote down how I think about it now. No product names here. The picture works for most cloud services that have two containers: an account and the things inside it.</p><h3>Think “company” and “offices”</h3><p>Many services give you two containers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V-wjQt3L3sCMD974JXw1OQ.png" /></figure><ul><li><strong>The company (organization).</strong> The contract, the bill, and the member list live here. One company, one contract.</li><li><strong>The offices (projects).</strong> This is where an app actually runs. The keys, the safe and the supplies belong to that office only.</li></ul><p>The bill goes to the company. The work happens in the offices. And because the contract belongs to the company, you often cannot give one office a different tier from the others inside the same company.</p><h3>Three ways to split</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PbOR4ibO47q78-Gwm6iuhw.png" /></figure><ol><li><strong>By department.</strong> Sales, HR and engineering each get an office. One bill for the company.</li><li><strong>By customer.</strong> Each client gets a dedicated office, so nothing mixes. It gets heavy to manage as the number grows.</li><li><strong>Live and test.</strong> Inside one company, keep the real thing and the experiments apart, so a slip does not break the live one.</li></ol><p>There is no single right answer. I decide by asking: <strong>what must never be mixed?</strong></p><ul><li>Customers’ data must never mix: one office per customer.</li><li>Different people should pay different bills: separate companies.</li><li>A mistake must not reach the real app: live and test offices.</li></ul><h3>The free-slots trap</h3><p>Free tiers often limit how many things you can create. The way they count matters. It can be per person, or the total across everyone with admin rights in the company.</p><blockquote><em>“I’ve only made one. Why can’t I make another?”</em></blockquote><p>Maybe another admin in the same company already used up the shared allowance. I have not hit this myself, but I read about it in one service’s documentation and it was a surprise. Read how your service counts, once.</p><h3>A yearly inventory: four questions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qBf9-tjwS3HuAesYKWgqQg.png" /></figure><ol><li><strong>Where is it?</strong> Which company holds which office.</li><li><strong>Is it running?</strong> Is anything paused or stuck?</li><li><strong>Whose is it?</strong> Is the owner still around?</li><li><strong>What does it cost?</strong> Cost often grows with the number of things running.</li></ol><p>The most important rule:</p><blockquote><strong><em>Do not delete something just because it looks unused.</em></strong></blockquote><p>“Not running” and “not needed” are different. Ask the owner first. Many services do not charge for things that are paused (check yours), so there is rarely a reason to rush.</p><h3>Make hand-over easy</h3><p>When someone leaves, the pain is that nobody sees the whole picture. A few cheap habits help:</p><ul><li>Put the department or customer in the <strong>name</strong> of each office.</li><li>Have <strong>at least two admins</strong>, so one person leaving does not lock you out.</li><li>Keep a <strong>short note</strong> of the last inventory.</li></ul><h3>What does it cost?</h3><p>In many services the contract has a base fee, and each running office adds the cost of its own machine. So <strong>the number of running offices</strong> is what moves the bill. Before you add the fifth one, ask:</p><blockquote><em>If I had three of these, what would it cost per month?</em></blockquote><h3>What to do today</h3><ol><li>List every “office” you have.</li><li>Write an owner’s name next to each.</li><li>Find out how long each has been idle. Confirm before deleting anything.</li></ol><h3>The short version</h3><ul><li>The contract is the <strong>company</strong>. The work is in the <strong>offices</strong>.</li><li>Split by <strong>what must never be mixed</strong>.</li><li>Free allowances can be counted <strong>across people</strong>. Check how.</li><li>Inventory day is a day to <strong>confirm</strong>, not to delete.</li></ul><p>If you want the hands-on version, with real screens, a real transfer between two organizations, and a small inventory app, here it is: <a href="https://dev.to/tomozilla/organizations-vs-projects-in-supabase-move-a-project-between-orgs-audit-dormant-ones-and-build-a-bgf">https://dev.to/tomozilla/organizations-vs-projects-in-supabase-move-a-project-between-orgs-audit-dormant-ones-and-build-a-bgf</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f19c78f2ba25" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Which Plan Do You Actually Need?]]></title>
            <link>https://medium.com/@tomozilla/which-plan-do-you-actually-need-1613866c4c24?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/1613866c4c24</guid>
            <category><![CDATA[supabase]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[pricing-strategy]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 02:37:30 GMT</pubDate>
            <atom:updated>2026-11-04T05:41:44.662Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A plain-English guide for people who build business apps: the staircase behind every pricing table, the four things you really pay for, and the three moments when it is time to step up.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NptveGVcTo-VLlOL3tcPmA.png" /></figure><p>You built an app with AI help. It works. Now someone asks, “Should we move to a paid plan?” and the pricing table in front of you has forty rows.</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I read the pricing pages, checked the numbers, and edited the text. The mistakes are mine.</em></blockquote><p>I could not answer that question the first time either. So I stopped reading the table row by row and asked a different one: what do I actually pay for? This guide is that answer. No product names. The idea works for any service with tiers.</p><h3>A pricing table is a staircase</h3><p>Plans are built like steps. You stand on one, and the step decides what you need.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zVu49ryxSRRF4QygF65XVg.png" /></figure><ul><li><strong>Step 1, Try.</strong> Just you, or a few people. If it stops or vanishes, you start over.</li><li><strong>Step 2, Public.</strong> Strangers use it. Downtime hurts. Lost data cannot be redone.</li><li><strong>Step 3, Company.</strong> There is an internal review. Everyone should come in through one front door. You have to explain your setup to someone.</li><li><strong>Step 4, Large organization.</strong> A named contact, clear promises, terms made to fit.</li></ul><p>No step is better than another. A market stall does not need an office tower. But a shop that people visit every day should not stay a stall in the rain.</p><h3>What you pay for comes down to four things</h3><p>Forty rows sound like forty decisions. They are four.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XBoBsMzLdaVxSCIQH9bVTg.png" /></figure><ol><li><strong>Room.</strong> How much data you keep, how many people use it, how much traffic moves.</li><li><strong>Protection.</strong> Backups, and how far back you can go.</li><li><strong>Who gets in.</strong> How people log in and who may do what. Think of a company badge.</li><li><strong>Support.</strong> When you are stuck, who answers, and how fast.</li></ol><p>You do not need all four today. Pick the ones your service needs now.</p><h3>Protection is where people get confused</h3><p>This is the one that surprised me most, so let me slow down.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f2RTJhreVwQWgzkNRF1scA.png" /></figure><p>There are two different things people call “backup”:</p><ul><li><strong>A nightly copy.</strong> You can only return to last night. If someone deletes data at noon, you get back last night’s version, minus the morning.</li><li><strong>A rewind to a second ago.</strong> You can go back to just before the mistake. This usually costs extra.</li></ul><p>I kept hearing “backups are expensive.” When I looked closer, people were mixing the two. In my reading, the nightly copy comes with paid tiers, and the rewind is the add-on. Check this on the service you use. Policies differ.</p><p>Ask yourself one question:</p><blockquote><em>If I lost everything since last night, would that be a problem?</em></blockquote><p>If the answer is “no big deal,” a nightly copy may be enough. If it is “absolutely not,” look at the rewind.</p><p>One more trap. A backup of your database may <strong>not</strong> include uploaded files such as images. You can restore the records and still be missing the pictures. Ask where your files live and whether they are covered.</p><h3>Three moments to step up</h3><p>I settled on three signs that it is time to move up a step.</p><ol><li><strong>Someone depends on it.</strong> A free tier may pause a project that is not being used. That is fine for a test and a problem for a tool people open every morning.</li><li><strong>You have data you cannot redo.</strong> Orders, notes, records of conversations.</li><li><strong>Someone asks you to explain.</strong> A security review at a customer, an internal approval, a questionnaire.</li></ol><p>If none of these is true yet, you probably do not need to move. That is allowed.</p><h3>A bill has three parts</h3><p>Looking at the monthly price alone is a common mistake. A bill usually has three parts:</p><ul><li><strong>The base fee</strong> for the plan.</li><li><strong>A charge per project</strong>, based on how big a machine each one gets.</li><li><strong>Usage beyond what is included</strong>: more users, more traffic, more storage.</li></ul><p>A cheap base fee can turn into a surprising bill when your app gets popular. Before you commit, do one small exercise: what happens to the bill if your users grow tenfold?</p><h3>What to do today</h3><ol><li>Write down which step you are on: trying, public, internal, or large.</li><li>Ask your team the backup question: “What if we lose everything since last night?”</li><li>Read only the pricing rows that match the four boxes. Skip the rest for now.</li></ol><p>I stopped trying to understand the whole table before deciding. Knowing my step, and knowing what would hurt, was enough.</p><h3>The short version</h3><ul><li>A pricing table is a <strong>staircase</strong>. Know which step you are on.</li><li>You pay for <strong>room, protection, who gets in, and support</strong>.</li><li><strong>Backups</strong> are the most misunderstood part: nightly copy and rewind are different things.</li><li>Step up when <strong>someone depends on it</strong>, <strong>data cannot be redone</strong>, or <strong>you have to explain</strong>.</li><li>Look at the <strong>whole bill</strong>, not just the base fee.</li></ul><p>If you want to see how I applied this to a real product, with screenshots and numbers, I wrote a hands-on version: <a href="https://dev.to/tomozilla/free-pro-team-enterprise-what-each-supabase-plan-gives-you-mapped-to-real-use-cases-plus-a-4o2i">https://dev.to/tomozilla/free-pro-team-enterprise-what-each-supabase-plan-gives-you-mapped-to-real-use-cases-plus-a-4o2i</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1613866c4c24" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your Page Is Slow Because of One Big Image]]></title>
            <link>https://medium.com/@tomozilla/your-page-is-slow-because-of-one-big-image-66bc2dd1fffd?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/66bc2dd1fffd</guid>
            <category><![CDATA[database]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 06:51:49 GMT</pubDate>
            <atom:updated>2026-11-04T05:40:36.105Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A plain-English guide to automatic image sizing for people building content apps: why one large picture slows every visit, how “one original, sizes on request” works, and the four things that surprised me.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QBjdzDhCLbj24LC4gjyIiQ.png" /></figure><p>You build a small announcements page with AI help. Pictures show up, the layout looks right, and then you open it on a phone and wait. The text is there. The images crawl in.</p><p>The usual cause is simple: the page serves a huge picture where a small one would do. I ran a small experiment to see how big the difference is and what goes wrong when you automate the fix.</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I ran the tests, checked the numbers, and edited the text. The mistakes are mine.</em></blockquote><h3>Are you shipping a huge crate for a tiny box?</h3><p>If you upload a photo straight from a camera or a design tool and show it as a small card, the visitor’s phone still downloads the full-size file and shrinks it on screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-eW_c8Yyz12t2imsBAZcSg.png" /></figure><p>I took one generated picture, 3200 by 2000 pixels, 570 KB, and served it five ways:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2sfLvVKPsZXsn68_Y1ZBtg.png" /></figure><p>At 400 pixels wide, the same picture was <strong>5.6 KB instead of 570 KB</strong>, about one percent. That is a measurement, with a big caveat: my picture is a generated illustration with large flat areas, which compresses far better than a real photograph. Expect a smaller win on photos, though still a large one.</p><h3>One original, sizes on request</h3><p>The idea behind automatic sizing is to store <strong>one</strong> original and let the sizes be chosen when the image is shown.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nDc3TfcAUF7HLgrWdEVO4g.png" /></figure><p>The size lives in the address of the image, for example “this picture, 400 pixels wide.” A list page asks for a small version, an article page asks for a larger one, and nobody has to export and upload several copies. If you add a new size later, it is a new address, not new files.</p><h3>What surprised me</h3><p>I tried this in a tiny announcements app: an admin page where an editor uploads a title, text and a cover image, and a public page that lists and displays them. Four things did not go as I expected.</p><p><strong>1. Giving only a width cropped the picture.</strong> I asked for “400 pixels wide” and nothing else. The result was 400 by <strong>2,000</strong>: a thin tall strip cut out of the middle. The default behavior is to fill the requested box and cut off what does not fit. Asking explicitly for “fit inside” gave a clean 400 by 250.</p><p><strong>2. The file format depends on the browser.</strong> The same 400-pixel request came back as a modern compressed format (5.6 KB) when the request said it understands that format, and as a plain PNG (65.5 KB) when it did not. That is a 12 times difference from one missing hint. Browsers send the hint, so users are fine, but if you test with a plain tool you will see big numbers and wonder why.</p><p><strong>3. A renamed text file got through.</strong> The admin page checked file types, but the check was based on the file’s name. I renamed a six-byte text file to “.png” and it was accepted, saved and published. The resizing service then failed on it with a server error, and my page showed a broken image with a message blaming “transformation unavailable.” The page did not even tell me the real problem: the file was not an image. I fixed my page to look at the file’s first bytes, which is a real improvement, but it is still a check in the browser. Anyone can send files without my page. A real system needs rules on the server too.</p><p><strong>4. The settings said no, and it worked anyway.</strong> The provider’s documentation says this feature is for paid plans, and the settings screen showed the switch off on my free project. The resizing still worked. I do not know why, and it could stop working or become billable. I did not pay for anything. Read the current documentation and pricing before you rely on it.</p><h3>Four things to check before you rely on it</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F6L9qAzr3spC_zRgk78bxw.png" /></figure><ol><li><strong>Plan and price.</strong> It may need a paid plan and may be billed per distinct image processed. In the provider’s documentation at the time of writing, that was a small number included, then a per-thousand charge. I did not test a paid plan.</li><li><strong>Crop surprises.</strong> Decide whether you want “fill and crop” or “fit inside” for each place an image appears.</li><li><strong>Bad files.</strong> Check what is really inside an upload, on the server, not just the file name.</li><li><strong>Who may upload and delete.</strong> In my demo, every logged-in user was an editor. I only noticed because a login left over from a different demo could open the admin page and edit. Restrict it by role in anything real.</li></ol><h3>When to do the resizing</h3><p>You can resize on request (what I tried), in advance when the file is uploaded, or when you publish. On request is the least work for editors and the most flexible. In advance can be cheaper if you serve many sizes of the same few images, and the provider’s own advice for keeping usage down is to pre-generate common sizes and cache. I did not compare the options on a real workload.</p><h3>What it costs</h3><p>My test cost nothing: I stayed on a free plan and did not enable or pay for anything. For reference, the documentation says the feature is for paid plans, with a few images included and a per-thousand charge beyond that, where “images” means distinct originals processed in a billing period, however many sizes you ask for. I did not look at a bill. The saving on the other side is smaller downloads for your visitors, and less data sent, which can matter on mobile.</p><h3>Questions to ask your AI assistant</h3><ul><li>“How will this page serve a small image for the list and a larger one for the article, without me making copies?”</li><li>“What happens if I only give a width? Will the picture be cropped?”</li><li>“What image formats will visitors actually receive, and does that depend on their browser?”</li><li>“How do we check that an uploaded file is really an image, on the server?”</li><li>“Does this need a paid plan, and how is it billed?”</li></ul><h3>What I did not verify</h3><ul><li>Real photographs. My sample is a generated picture with flat colors.</li><li>Private images with temporary access links.</li><li>A paid plan, or why the feature worked on my free project.</li><li>Phones and other browsers.</li></ul><h3>Summary</h3><ul><li>Serving a big image where a small one fits costs every visitor. In my sample: 570 KB versus 5.6 KB.</li><li>Store one original and ask for the size when you show it.</li><li>A width alone can crop; the format depends on the browser; file-type checks on a page are not enough; and the plan rules may not match what you observe.</li><li>Decide who may upload, and check uploads on the server.</li></ul><p>If you want the hands-on version, with the commands, the numbers and the small CMS, I wrote it up for developers: <a href="https://dev.to/tomozilla/serve-one-image-at-many-sizes-with-supabase-storage-image-transformations-measurements-surprises-27cb">https://dev.to/tomozilla/serve-one-image-at-many-sizes-with-supabase-storage-image-transformations-measurements-surprises-27cb</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66bc2dd1fffd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When “Connected” Isn’t True: Real-Time Screens, Explained]]></title>
            <link>https://medium.com/@tomozilla/when-connected-isnt-true-a-plain-english-guide-to-real-time-screens-ae4327fd4384?source=rss-2e2d9e39db75------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae4327fd4384</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[tomozilla]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 04:08:39 GMT</pubDate>
            <atom:updated>2026-11-04T05:27:58.233Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How a screen can change without a refresh button, why someone who arrives late sees an empty room, and the quiet failure that fooled me for 46 seconds.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JUS4llZMyj-G7CHLhm0yaw.png" /></figure><p>At some point a request lands on every app builder’s desk: “When one person updates something, everyone else should see it right away.” Or: “Show who is looking at this page.” Or: “I’m tired of pressing refresh.”</p><p>That is real-time. The idea is simple, and the failure modes are not obvious. I built two small demos to find out where it goes wrong, and I measured what I could.</p><blockquote><strong><em>How this was made:</em></strong><em> I used Claude to help draft this article. I ran the tests, checked the numbers, and edited the text. The mistakes are mine.</em></blockquote><h3>Normally, you go and look</h3><p>A normal web page works like this: when you open it or press a button, it asks the server, “Anything new?”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jlk8gjXHhHwoh_lt8AyhEQ.png" /></figure><p>It is like walking to the mailbox again and again. Most trips find nothing, and if you only check once an hour, you miss things.</p><p>Real-time flips it. The connection stays open, and when something changes, the server tells you. Think of leaving a phone line open instead of calling back every minute.</p><h3>My first test: a two-player game</h3><p>To feel the difference, I built tic-tac-toe that two people can play in different browser tabs. Alice puts an X in the center and Bob’s tab shows it a moment later. In my test a move showed up in the other tab after about 0.1 seconds. That is one measurement on one computer, not a promise about the real internet.</p><p>Two roles do the work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iIidpMMmxfg0HNztMRritw.png" /></figure><ul><li><strong>An announcement</strong> (“Alice put an X in the center”). Everyone currently in the room hears it.</li><li><strong>A sign-in sheet</strong> (“here now: Alice, Bob, Carol watching”). It updates as people arrive and leave. When I closed Bob’s tab, he vanished from Alice’s list in about a tenth of a second.</li></ul><p>Neither one stores the game. That detail is where I got tripped up.</p><h3>What surprised me: the person who joins late</h3><p>Alice and Bob played three moves. Then Carol opened the page to watch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BMQ7Kng1pbsY1pynK1cdow.png" /></figure><p>Carol saw an <strong>empty board</strong>. It even said “X’s turn” while the game was actually waiting for O. She had missed the announcements, and nobody keeps a copy of announcements.</p><p>I fixed it the simple way: when Carol joins, she asks “what is the board now?” and a player answers. That works, but it depends on a player being there to answer. The better design, which I built in the second demo, is to keep the real state in a database and use announcements only to say “something changed.” Then anyone arriving, at any time, just reads the current state.</p><p>My second demo was a live order board: three columns (received, cooking, done) where people move cards. When one person moves a card, everyone sees it. A late arrival saw every order immediately. A change took between about half a second and 1.3 seconds to show up elsewhere, slower than the game because it goes through the database. I measured six moves: 497, 739, 754, 764, 859 and 1,265 milliseconds.</p><h3>The quiet failure: a status light that was wrong</h3><p>My board has a small indicator at the top that says “Connected.” I tested what happens when the connection breaks. The easy case works: if the connection is closed cleanly, the page notices quickly, turns grey and says the data may be out of date.</p><p>The harder case is a network that simply stalls, with no clean close, like a bad Wi-Fi patch. I simulated that by blocking one tab’s real-time traffic without closing anything. Then I moved a card in another tab and watched the blocked tab.</p><p>For <strong>46 seconds</strong>, the blocked tab kept saying “Connected” in green, and it showed the card in the wrong column. Nothing on screen hinted that anything was wrong. After 46 seconds it finally turned grey, and when traffic came back it reconnected and reloaded the correct state within about 3 seconds.</p><p>I tightened how often the page checks that the connection is alive, from the default of every 25 seconds to every 10. The same test then flagged the problem after 16 seconds. That is still not instant. A real-time screen can show stale data with a green light for a while, and the better the design, the shorter and clearer that window is.</p><h3>Where real-time fits</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4n6zzVMLdvs7PHjXn6Imqg.png" /></figure><p>It suits things people watch together: order and ticket boards, “who is viewing” indicators, chat, shared whiteboards and games. It is a poor fit for things that rarely change, and it is not a record: a notification can be missed, so keep the truth in a database.</p><h3>What to decide before you add it</h3><ol><li><strong>Who may join the room?</strong> In my demo anyone who knew how could join and send messages. If the room matters, only logged-in people should get in. I did not test that setup.</li><li><strong>Where are the rules decided?</strong> My game decided who won in the browser, so a determined player could cheat. If money or points are involved, the rules need to be checked on the server.</li><li><strong>What happens when the connection drops, and what does the screen say?</strong> Decide it in advance. My answer: turn grey, say the data may be out of date, reconnect, and reload everything.</li></ol><h3>What it costs</h3><p>My tests cost nothing on a free plan. The provider’s documentation lists limits for a free plan, checked on 22 October 2026: 2 million real-time messages a month and 200 simultaneous connections, with usage-based pricing above that on paid plans. I did not check exactly how messages are counted, so I cannot turn “five people using my board” into a message count. Something that streams every mouse movement to everyone would, I think, reach the limit quickly, but I did not try it.</p><h3>Questions to ask your AI assistant</h3><ul><li>“When one person changes this, how will everyone else’s screen update without a refresh?”</li><li>“What does someone who joins late see? Where does the current state live?”</li><li>“How do we know the connection is alive, and what does the screen show when it isn’t?”</li><li>“Who is allowed to join this live room, and where are the rules enforced?”</li><li>“Estimate the monthly message and connection usage for our expected number of users.”</li></ul><h3>What I did not verify</h3><ul><li>A tab that was really in the background for a long time. My test tool keeps all tabs “visible”, so I could not reproduce that case.</li><li>Other devices and networks. I used tabs on one computer.</li><li>Many simultaneous users, private rooms and how messages are counted for billing.</li></ul><h3>Summary</h3><ul><li>Normal screens go and look. Real-time screens get told.</li><li>In my test, a message took about 0.1 s and a database-driven change took about 0.5 to 1.3 s.</li><li>Announcements are not memory. Someone who arrives late sees nothing unless the state lives in a database.</li><li>A “Connected” light can lie. A silent stall left mine green for 46 seconds, or 16 with a faster check.</li><li>Decide who may join, where the rules run, and what the screen says when the connection drops.</li></ul><p>If you want the hands-on version, with the code, the measurements and both demos, I wrote it up for developers: <a href="https://dev.to/tomozilla/supabase-realtime-from-scratch-tic-tac-toe-with-broadcast-and-presence-then-a-live-order-board-1d9m">https://dev.to/tomozilla/supabase-realtime-from-scratch-tic-tac-toe-with-broadcast-and-presence-then-a-live-order-board-1d9m</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae4327fd4384" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>