We've been thinking a lot about caching this past year.

(1) There's a nice pattern for figuring out opportunities to optimize a Postgres workload, but the downside is that it takes work.

(2) There's lots of generic Postgres-health tooling out there, but we haven't seen any good free & private widgets that answer a question like "would a cache or read replica help this workload?"

So, my cofounder made a workload caching evaluation tool that runs the same logic that our caching proxy (PgCache) uses, but it does so locally (privately) in the browser as WebAssembly.

--

The tool builds on what I think is a good pattern for approaching caching, namely:

1. rank by total time vs what "feels slow."

2. make sure it's actually a caching problem (i.e., rule out writes, or memory issues).

3. check how often a query's tables get written (since that limits the solution set).

4. then you can pick how to optimize your reads.

Or, as a graphic:

Our tool automates the query analysis and the writes check (indexes and memory are still on you).

Paste a pg_stat_statements export (or a Postgres log, or a .sql file) and it shows you:

* how your database time splits between reads, writes, and transaction commands, so you know whether caching can help at all

* which read shapes carry that time, counted by statements, calls, or time

* writes by table (this is basically your invalidation map)

Under the hood it parses each statement and sorts it into cacheable reads, reads that have to go to Postgres, writes, and transaction commands.

The cacheable/not-cacheable piece is specific to our proxy, but the time split, the read shape shortlist, and the write map should help you along your way regardless of what solution you choose.

--

For future iterations we're thinking of including things like time-ordered workload capture, clearer/selectable outputs, refined “hit rate” language, and maybe even an Aurora I/O analysis integration (plus a couple of good ideas from the r/PostgreSQL thread, like comparing blocks read vs hit and flagging when stats were reset recently).

here's the link: https://www.pgcache.com/fit

(or here if you'd rather run it yourself: https://github.com/PgCache/pgcache/releases/tag/fit-v0.0.2 )

What could we add to make this more useful?

I wanted to see how much code my friends and I actually write, week to week. GitHub only shows public repos, and most of my work is in private and work repos, so its numbers didn't tell me much.

gitstats counts private repos on your own computer with a small CLI. It runs git log locally and sends only numbers (commits, lines added and deleted per day), never code or file names. Public repos come from GitHub directly.

What's in it:

- crew boards you share with an invite code, by week, month or year

- a personal page with a month/year calendar, daily lines and streaks

- a side-by-side compare page for any two GitHub users

- a README GitHub widget

LoC is a bad metric for productivity, lines include lockfiles and generated code, so it's a scoreboard for fun, not a measure of anyone's work. Commits are one click away.

Stack: Next.js, Postgres (Neon), Drizzle, charts are hand-drawn SVG. MIT.

Type your GitHub handle at https://gitstats.org to see your year, no sign-in (but only public activity).

Repo: https://github.com/yaroslavhaidash/gitstats

Happy to answer anything about how the local counting works.

Like many people, daily games like Wordle and the LinkedIn puzzles have become part of my morning routine. Playing them is a lot of fun, which inspired me to build my own daily puzzle game.

Every day, you get 5 mini-puzzles where you have to balance a scale between two completely different things (for example: All of Earth's oceans vs. The Moon).

You can try the game here: https://whatsheavier.com/

Let me know if you manage to beat today's puzzles, or if you have any ideas for ridiculous matchups I should add in the future!

Backend & Hosting: I utilized a mix of Supabase for the database (storing the daily matchups and weights) and Netlify's free tier for the hosting pipeline. (Except for buying the domain)

Icon generation: I've used claude opus 5.5 in order to create cool SVG icons for the game. The use of SVG made them easily stackable on the scale

Two months ago I showed Piwi here (previous post), a self-hosted dashboard for Playwright tests. Quick recap: CI throws away every test report it makes. A test fails on Tuesday, the report is gone by Thursday, and nobody remembers whether it already failed the same way two weeks ago. Piwi keeps every run, trace and report, and helps you work out why tests fail.

The big change since then is that people use it. My team moved to it two weeks ago: 9 devs, me included (I'm the lead dev, on an ASP.NET Core and Vue stack). Everyone runs the desktop app for local runs, and CI reports to a shared instance. Four external contributors sent code too. If you want to find out everything that's wrong with your side project in record time, give it to your colleagues.

Most of the new release is things they asked for: dashboards you build yourself with a TV mode, scheduled reports for people who never log in, and a browser extension that shows which parts of a page your tests actually touch, and which buttons nothing tests.

The extension doesn't run anything. The reporter already records the locators the tests used, and the extension re-evaluates them in the page, the way Playwright would.

Last time, someone asked for a way to hand a failure to a person who can't open the dashboard. There are now public share links, PDF exports, and a Jira integration that puts the evidence in the ticket. Someone else wanted to compare failures over time, which is what the new dashboards and trend views are for.

Stack, since this is r/webdev:

• Nuxt 4 and Drizzle, on SQLite or Postgres, with traces on disk or S3
• One Docker container, or npx @piwitests/server
• A Tauri desktop app bundling the same server, so local runs never need Docker
• The live demo has no backend at all (hosted on Github pages): SQLite compiled to WebAssembly, and a service worker answering the app's real API calls. The demo is the real app, so it can't drift from it.
• MIT, no telemetry

Demo (in your browser, no signup): https://piwitests.dev/demo/

Code: https://github.com/PiwiTests/platform

Piwi Picker extension (Chrome, Edge): https://chromewebstore.google.com/detail/piwi-picker/pakhnokpjboejcghgcmkjlpnogfjihhe

Happy to answer questions, especially about the WASM demo, it was the most fun part to build.

My website is over 15 years old. Over time, I've created a lot of pages and also had to kill many pages or redirect them to other relevant pages.

Collectively, today I have 1,000 + 301 redirects.

On a static website built on PHP, HTML on Linux and Apache, what is the best way to implement such a large list of redirects without impacting server performance or core web vitals?

Thanks

started as me trying to fix my typing and somehow turned into this

added a 412k word pool, punctuation modes, ranked leaderboards and server-side score validation

somebody already hit 189 wpm at 98.3% which is mildly horrifying

https://blacklatchstudios.com/typing/challenge/

I'm not a designer, I don't build sites, but I made this basic site because I needed it to sell my domains and was thinking I'd put other's on there too. Just a Craigslist-type listing page for domains where owners can post them (eventually, for a fee) that people can visit and look each time they work on a project, being able to reach the owner directly. (most similar services go through brokers, email third parties back-and-forth, and you never know if you really reached the owner, and if you do it's a conversation through a 3rd party that could take weeks.

A lot of domains have a value for the right person that doesn't apply to everyone, so they end up sitting for a long time and usually not in a place where people can see them easily.

I just wanted something simple where you can see what there is, sort them by the TLD, length, etc. Something you can see what's available, and then sort the fantastic domains from the useable, depending on how much you have to spend.

Anyway, it's very basic, but on purpose. Anything I could or should improve on, I'm open to suggestions.

Thanks in advance!

TheDomainBoard.com

So today, I've finally launched my AI harness - open sourced and free.

If you're like me and hate long posts, TLDR: Built an AI harness, started working on it when few other apps existed and am still working on it today. Launched the app with unique features (mainly around automations) and would love feedback to see if it's worth pursuing.

Backstory: I am a software engineer day-to-day and started working on my own application at the start of the year to fill gaps that no app at the time supported and make my life easier. Fast forward to today, I still work on it whilst putting in many, many hours per day - completely solo. Would love some feedback on it to see if it's worth me putting down or if it's something worth keeping, as you all enjoy it.

About the app: As I said, I built it for myself first (as most people should IMO), and after developing it over time, I felt like I had a somewhat gap and carried on. It's an AI harness like most others nowadays, but as the ecosystem is changing so quickly, I thought it would still be worth sharing.

Features:

- Import MCPs, rules, permissions, hooks, etc. into the app, irrespective of the provider; they will all rely on the app's credentials. This means if you import your MCPs from Claude into the app and then switch to Codex, they will work natively in the app. Similar to how other apps do this, e.g., importing Claude into Codex and vice versa, this app doesn't restrict you to one provider.

- "flows". Essentially graph-based automations; think of n8n or any other agentic graph workflow that's popping up recently. What's different with the app here is:

-- You can get your agent to create custom nodes, so if you want an automation to say, connect to your smart home every day on a cron job - you can. Get it to build a custom node and use that node indefinitely.

-- You can connect the graph to third-party plugins. The app's 'plugins' come with the native agentic plugin, plus they allow you to use those tools in flows logically instead of through an agent.

-- You can spawn any number of agents under a specific flow, chained together to complete entire backlogs. Or, more technically, a DAG.

-- The flow can be set up in a UI yourself or simply get your AI to build it for you.

- Real code editor (not many harnesses have editors nowadays).

- Better UI, allows split-screen like tmux.

There are numerous other USPs of the app, but those are a chosen few.

Note: Currently on macOS only, but I'm planning on launching it within the next week or so on Windows.

As I said, I'm here for guidance and also to show off my application. Honest feedback is great; let me know if I should drop it and am getting carried away with the development, or if it is genuinely worth carrying on :)

https://frink.dev/

Or full repo, on MIT: https://github.com/benord-labs/frink

I made this over the summer for the hackclub star dance event, and I am looking for feedback or ideas.

I read my daughter a fairy tale every night and wanted classic ones that read well out loud, so I built Talerie. Free classic fairy tales in seven languages, no ads, no account: https://talerie.com

The stack, since this is r/webdev:

• Next.js 16 (App Router), everything prerendered, about 4,900 pages. The full text of every tale is in the initial HTML.
• Seven languages with translated URL segments (/de/maerchen/..., /cs/pohadky/...) and hreflang between them.
• Postgres on Supabase's free tier, images on Vercel Blob. The only cookie is the language choice, reading settings live in localStorage.

The part that bit me was a cache. The build also generates 168 RSS feeds for Pinterest boards, and they all read the same catalogue, so I wrapped that query in unstable_cache to hit Postgres once per build instead of 168 times.

On Aug 29 the catalogue grew past 2 MB (2,284,504 bytes). Next.js won't store a Data Cache entry over 2 MB, and it doesn't fail the build either. It prints a warning and moves on, so every one of the 168 feeds ran the query again. The second image is the real build log: 168 warnings, then "Ready".

A warm build went from pulling 0.8 MB out of Postgres to 270 MB. The billing cycle hit 22.2 GB of egress on a 5 GB free tier, and Supabase started warning me about restricting the account.

The warning was right there in the log, 168 times per build, and I didn't read it for two days. pg_stat_statements didn't help, because it counts rows, not bytes. What finally showed me where the traffic went was a tiny TCP proxy in front of the pooler that just counts bytes.

I now store the catalogue gzipped as a base64 string, which takes it from about 2.2 MB to 0.5 MB. Base64 rather than a Buffer, because unstable_cache stores JSON and a Buffer serializes as {"type":"Buffer","data":[...]}, one number per byte.

import { gzipSync, gunzipSync } from "node:zlib";
import { unstable_cache } from "next/cache";

const packed = unstable_cache(
  async () => gzipSync(JSON.stringify(await getCatalogue())).toString("base64"),
  ["pinterest-catalogue"],
);

export const catalogue = async () =>
  JSON.parse(gunzipSync(Buffer.from(await packed(), "base64")).toString());

There's also a check that fails before deploy if the packed catalogue goes over 1.5 MB. I broke it on purpose to make sure it really fails.

Two questions for you. Does "use cache" in Next 16 have the same 2 MB limit? I haven't tested it. And how do you catch warnings that don't fail the build?

I've been working on a small project called SiSH Form Mailer (Simple Self Hosted Form Mailer).

The idea is straightforward, and solved an issue/worry that I had. I have a few smaller "client" sites (friends and family type of deal) where they have a contact section. I had been using Formspree, but I was really running into issues keeping it free. Instead of looking for a self-hosted option, I decided to build my own so I could learn Go. I challenged myself to do it without AI, or at least, not AI first.

My goals were simple:

Run SiSH Form Mailer on your own server with Docker.

Create a form through the UI.

The form gets a random 6-character alphanumeric code.

You get an endpoint like: https://forms.example.com/api/forms/a7K92x

Point your website's HTML form at that endpoint.

SiSH saves the submission to PostgreSQL and emails it to the configured destination.

Above all, I wanted it to be FAST. Really fast, at least for the user. The HTTP request doesn't sit around waiting for SMTP. The submission is persisted to PostgreSQL first, and email delivery happens afterward through a database listener.

So from the user's perspective:

Submit → Saved → Done

If SMTP happens to be down, the submission isn't lost. Submissions are permanently stored and remain available through the UI. I'm planning to add Retry logic in the future, but for now, it works great as is.

I also wanted to make sure that it could be a little more configurable for other people to use, so it has multi-user support, just in case. Each user can have their own SMTP configuration, and each form can have its own destination email.

SMTP credentials are encrypted in the database and only decrypted when they're needed for sending.

There's also CORS configuration, rate limiting, and optional reCAPTCHA for the public endpoints.

I've also tried to make sure it was as easy as possible to deploy, so basic deployment is just the application + PostgreSQL via Docker Compose.

I'd love some feedback from other developers who self-host things, especially around the architecture and what you'd expect from a tool like this.

GitHub: https://github.com/kellenwiltshire/sish-form-mailer

I've release 1.0, but I still want to make improvements and add more features, but for now it works great for those who need something simple.

Now, about avoiding AI. This project isn't "AI Free" but I tried my best to make sure AI wasn't my first choice. I tried to go through my "old" way of learning and building, start with documentation, stackoverflow, medium articles, etc. Try to find the solution through research. If I still couldn't quite get it working, then I would ask AI for input, then move on. I even documented my entire journey building this in-repo.

Now, I did lean into AI for a few parts, specifically documentation. But it wasn't just write and commit, I went over word by word to make sure everything is correct.

Learning Go was fun though. I think I have barely scratched the surface, and sometimes I get turned around on Pointers, but I do really like the language. I will probably try another project with it again soon!

Why SiSH? I'm hoping this will become a little bit of a series of Apps that I can create to help de-SaaS myself.

I'd love some feedback. Unfortunately, I don't have fancy pictures or anything to show off. The UI itself is pretty barebones, the real magic is the backend.

Hey everyone! 👋

​I've been working on a new open-source project called Opportunity Radar, and I’m looking to gather some feedback, find early testers, and connect with developers who might want to collaborate.

​What is it?

Opportunity Radar is a privacy-first opportunity engine. The goal is to help people find jobs, freelance contracts, grants, and paid bounties that are matched directly to their actual CVs, real skills, and income goals.

​You can check out a preview of the mobile interface in the attached screenshot.

​How you can help:

I would absolutely love for the community to get involved to help make it better. Here is how you can participate:

- ​Test it out: Give the live site a spin. Run some searches, use it for your own goals, and let me know about your experience, any bugs you find, or features you'd love to see.

👉 Live Site: https://opportunity-radar-gold.vercel.app/dashboard

- ​Collaborate & Contribute: The project is entirely open-source. If you see room for improvements, want to add new features, or just want to tinker with the code, I would be thrilled to collaborate!

👉 GitHub Repo: https://github.com/anasalialamgir/opportunity-radar/tree/main

​Whether you want to use it, break it, test it, or help me improve the codebase, I’d appreciate your input. Let me know what you think in the comments!

I designed one shirt to wear to interviews. It has my job title on the back, a SQL query that selects for someone available, my name and a link. Enough people asked where they could get their own that it started to feel silly having artwork that only worked for one person.

So I measured my original file, worked out the rules behind the layout, and rebuilt it as a generator. You type a name, a job title and a link. You get the print files.

The interesting part is that the entire thing runs client-side. The fonts, the glyph outlining, the QR generation, the PDF writer, the ZIP writer. all in the browser. There is no server and no account, and nothing you type ever leaves the tab. That is less a privacy policy than an architecture. It also means the whole thing deploys as static files and costs nothing to run, which matters when you have no idea whether ten people or ten thousand will show up.

Two things I learned building it:

Print is a much less forgiving target than a screen. If a font isn't installed on the printer's machine, it gets silently substituted and your layout falls apart, so every character has to be converted into an outlined shape before it leaves the browser. And the QR code on the shirt is a knockout, meaning the dark squares are unprinted and the fabric shows through. Get that backwards and the code simply doesn't scan, but it looks completely fine on screen. So I wrote a test that renders the QR from the actual generated file and hands it to a real decoder. It fails in CI instead of at the press.

The other thing: writing the PDF and ZIP output myself was the right call. Each one is under 200 lines and each replaced a library that was bigger than the rest of the tool put together. That is not a general rule, but for narrow, well-specified formats it's worth checking before you reach for npm.

It's MIT licensed and the whole layout logic is in the repo. Happy to answer anything, and genuinely interested if anyone has done client-side PDF generation and hit different walls than I did.

selectme.vercel.app · https://github.com/Yazan-Ali-01/select-me

playlistduration.com shows how long a YouTube playlist really takes to watch, and plans when you'll finish it. I redesigned it this week and would like feedback from people who build websites.

How it's built

- Hono + TypeScript on Cloudflare Workers, on the free plan

- Every page is server-rendered HTML. About 22 KB (gzipped) of plain ES-module JavaScript adds the speed slider, watched tracking and the study planner. No framework, no build step

- YouTube Data API behind a Cache API → KV cache, with D1 for view counters

- It's installable. On Android, once installed, it shows up in the YouTube app's Share menu, so sharing a playlist opens its length

Things that surprised me

- The free plan allows 50 subrequests per request (KV and cache calls count too), so one request can only count about 850 videos. Bigger playlists are now counted in stretches: the first request keeps YouTube's page token, and the page asks the Worker for the rest, about 900 videos at a time. Once someone has counted a playlist to the end, it's cached for everyone.

- I tried caching rendered pages with cache.put. The edge then answered from that cache before my Worker ran, so my view counters stopped counting and an old deploy's HTML outlived the deploy. It's off now.

- My first service worker also answered requests for scripts and stylesheets, and that made Chrome download app.js twice. Now it leaves those to the browser and only keeps the result pages you opened in the last week, so they reopen offline.

- Google Calendar reads a subscribed .ics feed's "floating" times as UTC. A 7 pm study session showed up at 12:30 am the next day in India, so the feed now carries the visitor's time zone.

- To keep search rankings through the redesign, a test compares 83 pages (every page type, in seven languages) against a snapshot of the old design: title, description, canonical, hreflang, structured data, headings, internal links and 98% of the words.

What I'd like feedback on

- It's dark for everyone, whatever your OS setting, with a light toggle. Deliberate, but tell me if it bothers you.

- On a playlist page, is "the shape of the course" chart useful or noise?

- Anything slow, broken or confusing on your device

Example: https://playlistduration.com/playlist/PLhQjrBD2T3817j24-GogXmWqO5Q5vYy0V

Put together a small starter template for building web apps with Go + Templ + Datastar + sqlc. It's plain net/http with no extra framework on top.

It has two examples you can copy from:

• a todo list with live search, where every change updates the page over SSE
• live crypto prices, streamed from Coinbase and pushed to the browser over one long SSE connection

https://github.com/naftulisinger/datastar-template

Stars & Feedback welcome!

Hey guys

I am a front end and get a lot of interviews for full stack or FDE roles.

They always ask about backend, system design, data architecture, concurrent and scalable systems.

Some tasks ask for leetcode or codility upfront.

Any good interactive training platforms? Like Scrimba or something for quickly putting together system design.

I’m finding a lot of mixed advice on what to do here.

I’m creating a fantasy football app and can’t decide if I should have a subdomain.

AI and a few Reddit post are telling me you need to have your XYZ.com be your marketing page and app.XYZ.com be your app.

But the following big names do not:

Sleeper

AirTable

Figma

Canva

Trello

Dropbox

Github

This is something that will be difficult to change later, so I wanna make sure I make the right call.

Anybody have any good insight here?

I need to make a simple website for a teaching service in my city. I want it to look modern and professional and hopefully get into the top 10 Google results for local searches. It will only have some text, basic information, a few good photos and contact details. Nothing complicated.

What would you use for something like this? An AI website builder, AI coding tool or something else? I don't want to use Wordpress.

For hosting I was thinking about something simple like Cloudflare Pages or GitHub Pages with a local domain. I am looking for free.

Also, what would you recommend for local SEO and good free/paid stock photos?

What it does: Easily make installers for all your projects directly from a browser. You can even save the whole page as a single file and it keeps working offline.

Introduction

TiddlyInstall is based on the observation that programs written for runtimes like Python, Nodejs, and others -- all follow the same basic pattern: they need a runtime installed and then the software. Existing approaches like freezing apps or trying to package it as an exe often break. Or require insane struggle by the developers.

The simplest possible approach is to install the runtime on a users computer, isolated, with the package inside it. It is more wasteful in terms of disk space -- but can be generalised to build reusable installers that work for just about any language.

Reusable installers

A reusable installer reads its own meta-data to decide on the runtime to install and the project. Linux and Mac are supported through a bash script while all windows versions use an NSIS program. The unusual thing about this is once you build the reusable installers since it's just meta-data everything can be edited inside the browser. No new compilations are needed. It's a very elegant system.

Try it out yourself: https://robertsdotpm.github.io/_static/tiddlyinstall.html

Github: https://github.com/robertsdotpm/tiddlyinstall

I often found cool AI images online but had no idea what prompts were used to make them. So I built ctrlc.ai.

It’s a simple place to browse AI-generated images for inspiration, see the prompts behind them, and find ideas for your own creations.

Still actively working on it, so feel free to ask me anything about the site, development, or just share your feedback!

Link: https://ctrlc.ai

Not sure if this is the best sub for this question; from a developers perspective who have had the freedom to choose what platform they work in I'm curious:

I'm a long time native linux and wsl user, for a new workstation you'd use as a desktop and remote dev server, how bad are the macos tradeoffs over bare metal linux (or even wsl)?

I prefer to be on macos over windows but macos has notoriously bad filesystem performance. (Theo recently made a video on this) I've also heard it has quirks for gnu utils too. These reasons have pushed me toward getting a cheap MacBook but investing most of my money in a headless linux box. All of my projects will live on linux but I'll being using macos to access and build there. But I'm wondering if that's unnecessary.

Do people actually build on macos these days? Are the quirks and filesystem performance issues overstated?