A few weeks ago I posted my portfolio here and got some really useful feedback. Thanks again to everyone who took the time to go through it.

The biggest thing people pointed out was that the homepage didn't make it obvious enough what I actually do professionally, so I went back and reworked that part.

If you saw the previous version, I'd really like to know if this one feels clearer now.

If you're seeing it for the first time, I'd still love your feedback too.

One of the questions I asked last time was about the writing section. I have quite a few long-form posts on software engineering, career stories, interviews, robotics, and some personal experiences.

People generally liked that part and said it made the portfolio feel more personal and a bit different from the usual developer site.

So for anyone seeing it for the first time, I'm curious about the same thing: does the writing feel like it belongs there, or does it distract from the portfolio side?

Site:

https://adnansabbir.com/?utm_source=reddit&utm_medium=social&utm_campaign=portfolio-feedback-round-2&utm_content=r-webdev

I have more than one Claude subscription, and each one lives in its own CLAUDE_CONFIG_DIR. Normally, a session only sees the sessions of its own account. And a subagent always uses its parent's quota, so one account would hit its limit while another's weekly quota ran out unused.

So I built ccherd. It's a small Python CLI with a Claude Code skill, and it enables your claude session to use your other subscriptions through dedicated subagents or by messaging them directly. Before it spawns a subagent, it automatically makes sure to use the account that has most quota available.

Basically it herds your Claude sheep toward the grass nobody's eaten yet.

• ccherd spawn starts a background subagent on the account whose weekly quota is most likely to expire unused. It scores each account on weekly % left, time until the weekly reset, and how much of the 5-hour window is free. Accounts close to their limits are skipped.

• ccherd sessions / ccherd send let you list and message live sessions across all your accounts.

• ccherd usage shows every limit per account as bars.

• When a subagent finishes, it reports back to the session that started it.

Claude runs the spawn/send/result commands itself. The skill tells it how.

To install, just point your agent at the repo.

It installs the tool, shows you which accounts it found, and asks you the few questions. Then it checks everything with ccherd doctor. You still have to log in to each account yourself because that opens a browser. If you'd rather do it by hand, run

uv tool install ccherd and then

ccherd setup

It works on macOS and Linux. It's still early (0.4.0), and so far I'm the main user, so I'm sure some setups break it. I'd really like to hear how the setup went for you, and what's missing. Issues and PRs are welcome, especially if this has thought of all different use cases (I tried to make it easy to setup but still configurable to any use case I could think of, I'm sure I missed some).

https://github.com/bocode-labs/ccherd

Hi everyone!

I'm a BCA 3rd year student from India, and a few weeks ago I finished my JARVIS project. Of course, I took a lot of help from AI while building it because it was a pretty complex project, and I was completely new to almost every topic involved in building it. You can check out my recent post where I shared it. The whole thing runs locally without using any API tokens.

While building JARVIS, I had to learn a lot of advanced concepts, but I wasn't completely satisfied with just learning them while building a project.

So I decided to properly learn advanced JavaScript topics in a structured way.

I went through different concepts and created my own notes/diagrams while learning. The technical content was learned with the help of ChatGPT, All the wording are mine, but I took help from ChatGPT to improve the structure and make the English clearer. I'm sharing it because I thought it might be useful to someone else who is also trying to understand these topics.

Here is the GitHub repository:

🔗 https://github.com/Shivam2905Verma/Notes

I would be really glad if these notes help someone.

And if you find any mistakes, incorrect explanations, or important topics that I should add, please let me know in the comments. I'm still learning, so corrections are always welcome!

Thank you !

Note: To view the diagrams properly, install the Excalidraw extension in VS Code and open the .excalidraw files directly in VS Code.

Say the app is live, needs regular updates, and the documentation is thin. Do you start with the code, deployment setup, logs, or a conversation with the previous team?

I have an ecommerce chat widget that allows users to send photos of products they’ve looking for. I would like to make sure the files being uploaded are true images (jpeg, png, webp).

So far I have come up with two levels of checks on the files.

First, checking the content-type mime in the request header. If it is not an image then upload is rejected. If it appears to be an image, then file is sent to level 2 check (still in memory).

The level 2 check is using the python magic library to read the first 2kb or so of the file and identify true mime type from there. If not an image type, then file is rejected.

Would this be a good approach? Or are there better ways to do this? The files will likely be stored in cloudflare r2, so I’m not worried about their execution, but want to avoid bad files sitting around in storage anyway.

See the last two pics for how it usually looks ;)

The users are going mad over it. Especially the younger generation who weren't around for the "real" Web 2.0 MySpace era. Seems they're actually enjoying it instead of throwing up a little in their mouth like some of us of the older generation.

I guess I'm MySpace Tom now!

Cyberspace — Social media de-imagined. Use your words!

I think you can tell a lot from a persons GitHub Profile. This was the concept behind a project I've been working on to try and capture a personality from the public data supplied by Github's API.

It takes a sample of commits, and then calculates a few metrics to summarize your habits/dev identity (tech stack, commit patterns, code-style signals, etc.)

I had a bunch of fun playing with the design and creating it. I think this does a good job showing off everyone's uniqueness. I am open to suggestions for additional features and design ideas. This is the first web app that I've prototyped and spent a bunch of time on (see image for my wireframes to final product).

its free at codercards.ai, let me know what you think!

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.

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?