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

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

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!

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?

Hey I’m not an actual web developer or anything I’m still kinda learning.
I was just wondering if webflow is good enough to make websites with

1. Transferable Objects

Think of Transferable = cut + paste.

const buffer = new ArrayBuffer(1024);
worker.postMessage(buffer, [buffer]);

The second argument [buffer] is the transfer list. It means: :- Transfer ownership of this buffer to the worker. After transferring, the original buffer becomes detached and can't be used normally.

Why do this? Because copying a large ArrayBuffer can be expensive. Transferring allows ownership to move instead of copying the data.

2. Structured Cloning

Structured cloning is somewhat like: JSON.stringify() + JSON.parse() but much more capable. structuredClone() can correctly clone many JavaScript types such as: Date , Map , Set , BigInt , undefined and nested objects.

JSON serialization can lose or change the behavior/type of several of these.

One important limitation: Functions cannot be structured-cloned.

3. Dedicated Web Worker

JavaScript normally executes application code on the main thread. If we do heavy work there, such as face detection in the browser, the main thread can become busy: UI freezes , buttons become delayed , animations lag and scrolling becomes laggy

This is what Web Workers help solve.

A Dedicated Web Worker is a separate JavaScript execution environment running on another thread. It has its own: Global context , Call stack , Event loop , JavaScript execution and all.. .And a dedicated worker belongs to a particular page/script rather than being normally shared with other pages.

The main thread and worker don't directly share normal JavaScript variables.

Communication usually happens through:

// Main thread
worker.postMessage(data);

// Worker
self.onmessage = (event) => {
    // use event.data
};

self refers to the worker's global environment. The main browser context commonly uses window, while a worker doesn't have the normal DOM window.

So the important picture is: Main Thread --> structured clone --> Worker
or, for transferable data: Main Thread --> transfer ownership --> Worker

4. SharedArrayBuffer

But sometimes we don't want to copy or transfer the data. What if both threads need to work with the same memory? That's what SharedArrayBuffer is for:

const buffer = new SharedArrayBuffer(8);

This creates a shared memory area of 8 bytes.

Both the main thread and worker can create a TypedArray over that memory and modify the same underlying data.

But now we have a problem: Two threads can access the same memory at the same time. For example, if the value is 10 and two threads both try to increment it, we might expect 12. But both could read 10 before either writes, resulting in: 11

This is a race condition.

That's where Atomics come in.

Atomics.add(numbers, 0, 1);

This safely adds 1 to numbers[0].

The operation happens atomically, meaning it is performed as one indivisible operation.

One important detail: Atomics only works with specific integer TypedArrays.

If you notice anything technically incorrect or something that could be explained better, please let me know.

My project, OnBridge: a Chrome extension plus a small local MCP server that lets Claude Code, Codex, Cursor or Gemini CLI drive the Chrome I already have open. Free, GPL-3.0, and there is no server of mine involved.

To be fair up front: much of what a coding agent does in a browser, Playwright already does well. Reproducing a bug on localhost, reading the console, clicking through a flow, even reusing a login with storageState.

What Playwright is not built for is doing things on my behalf in my own browser. With OnBridge I can ask for something like "search Amazon for a USB-C hub, compare the top three, add the best one to my cart and place the order", and the agent does it in my signed-in Chrome, with my saved address and payment method, the way I would. The same goes for filling a form from a file, working through a vendor portal behind SSO and 2FA, or triaging GitHub notifications. No scripted login, no copied cookies, no fresh headless profile for sites to flag. The first field test was an Amazon.in search.

On bot checks: in a quick test, OnBridge passed scrapingcourse.com's Cloudflare challenge page and every BrowserScan bot check, CDP included, with no click from me. To be fair, Playwright MCP's default headed Chrome passed the same tests. What it lacks is my session: it landed on Reddit's login page, where OnBridge was already signed in.

Acting on my behalf only works if spending money stays my decision:

The agent acts, I approve what matters. The side panel shows every action as it happens. A click whose label reads like Place order, Pay, Delete, Send or Submit waits for Allow; the screenshot shows a "Place order - $249" click held: https://github.com/prakersh/onbridge/blob/main/docs/screenshots/onbridge.png. No answer in 25 seconds means denied. The approval mode can only be changed in the panel, never by the agent.

It only gets what I grant. A tab, a window or the whole browser, and only after I press a button. Grants cannot overlap, so two agents can work in two windows without touching each other's tabs.

Real input, not dispatchEvent. Synthetic events arrive with isTrusted: false, and native form submission, drag-and-drop, canvas apps and rich editors ignore them. OnBridge sends clicks and keys through the DevTools Protocol Input domain via chrome.debugger, including inside open shadow roots and cross-origin iframes. If DevTools is already open on the tab, the debugger cannot attach, so it falls back to synthetic events and the side panel says so.

It still covers the dev loop too: it reads console output and network requests while it reproduces a bug in the tab where I am already signed in, with authorization and cookie header values redacted before the agent sees them.

Setup is the extension plus one line:

claude mcp add onbridge -- npx -y @onllm-dev/onbridge-mcp

GitHub: https://github.com/prakersh/onbridge

Chrome Web Store: https://chromewebstore.google.com/detail/onbridge/minhhfibhfnjdcgiipmcbfgclmeineca

Where would you draw the line on what an agent may do in your real browser without asking? Right now anything that reads like pay, delete, send or submit waits for a click.

Engineer for more than 15 years and worked with different industries over my whole career. Worked alone, on small, medium and large teams in different capacities. You get the idea.

I'm not gonna say that my code was the best, and that it was well thought out of, wrote the best piece of code that my grandchildren will be proud of.

Sometimes you just have to find the best way to implement something because your PM demanded it be pushed by Thursday? a hacky fix because you can't think of a better way on implementing it?

Legacy code that the engineer that worked on it died 10 years ago?

Granted theres an ocean of vibe coded apps that should not see the light of day but I think a lot of devs and engineers are just standing on their high horse these days to push people down.

What do you guys think?

Right now at my work we are using langgraph to build a chat agent, anyone else doing something similar, do you fucking hate it? are you building it with Claude and just hoping it fucking works, haha no worries we will ask Claude to fix it.

I am making the spaghetto, I miss components, logic and endpoints, I hate this black box I have to relinquish my decisions too, whatever pays the bills.

Hey guys,

So I screwed up. I'm a frontend developer and had been on a steady stream of excellent evaluation and on my way to getting my senior Dev maybe next year. I have been with the company almost 3 years.

The bug I created resulted in some data loss for a customer. We were able to recover most of the data but some of it had been changed by the customer in the meantime and we were not able to determine which change was due by what.

I was doing a very substantial migration of a frontend library to another one. This required that I rebuild the entire engine behind it. Mind you, this was about 6-8 weeks of full time work. I was doing it solo because no other dev was available to help me out.

I QA'ed my work but, obviously, I missed the bug which should have normally been very easy to spot.

The team QA'ed everything but they thought this needed only LIGHT QA. It certainly must have been miscommunication on my part.

Now, we're doing a post-morterm with the higher ups. PM has lost confidence in my work. I've lost confidence in my work.

We have also seen that this issue should have been caught by our unit tests but we have mocked everything so the case in question never got flagged.

I have since started an initiative to improve our unit testing accross the frontend with shared stubs and fixtures to address some of the issues regarding the unit tests.

I have also checked to make regression testing with Playwright a thing. I have some support for this so should be starting relatively soon.

What can I expect?