Show HN for November 30, 2025

Hi HN! I've been building ReadyKit, an open-source SaaS boilerplate that handles all the hard parts: multi-tenant workspaces, Stripe billing, OAuth + MFA authentication, and a production-ready stack.

Built with Python/Flask, PostgreSQL, Redis, and Vue 3, it's designed for indie makers and teams who want to ship SaaS products fast. Clone, configure your OAuth and Stripe keys, and you're running in 5 minutes.

Features include automatic query scoping for workspace isolation, audit logs, role-based access, and a modern UX kit. MIT licensed and free forever.

GitHub: https://github.com/level09/readykit

Hi HN,

I just launched Tinyfocus, a small productivity tool designed specifically for solo founders and builders. The goal is simple: help you focus on what matters and get more done in less time.

Here’s what Tinyfocus does:

Lets you track your top tasks and prioritize efficiently.

Provides micro dashboards to keep your daily focus in check.

Lightweight, no distractions, no fluff.

I built it entirely by myself, iterating in public, and I wanted to share it with the community to get feedback.

It’s been crazy seeing how a simple tool can make such a difference in daily focus, especially when you’re juggling multiple projects as a solo founder.

Check it out here: tinyfoc.us

I’d love to hear your thoughts – any feedback, feature ideas, or bugs you notice.

Thanks!

hey HN,

I’ve been building this project through a lot of late nights and messy iterations, and it’s finally stable enough to share.

utm.one is a clean, distraction-free URL shortener with built-in UTM discipline. it auto-prevents duplicates, applies consistent naming, and keeps your tracking clean using the Clean-Track framework .

I’m launching a controlled beta, so things are intentionally simple and safe for testing.

would love feedback on:

1. does the flow feel intuitive? 2. anything confusing or missing? 3. would you trust it for real campaigns?

Website - https://utm.one

next up: a partner + affiliate program built into the same tracking architecture.

thanks for taking a look any feedback (good or brutal) really helps.

Hello HN!

I'm a European traveler, and during my last 6 months of travel I created an app to keep track of my expenses. I made it open-source and started to build a website and a documentation for other people to use it!

It's a fairly simple PWA that you can install on mobile that can help you set a budget, keep track of expenses and analyse what you spend.

Thanks for any feedback and keep traveling guys!

I built a browser-only tool that disrupts invisible AI watermarks using Canvas, geometry, noise, and JPEG recompression. No backend, no uploads, no tracking.

Pipeline: Shake – Random rotation (±0.5°) + slight zoom Stir – Low-amplitude RGB noise via getImageData Crush – JPEG recompression at ~0.85 quality

Tested with SynthID (Google Gemini AI watermarking), and it remained undetected in all tests.

Pipeline improvements? What would you add/change?

Github: https://github.com/ing-norante/unmarker.it

Hey HackerNews! Just wanted to share something slapped together recently, looking for feedback.

Context: I worked in both research and enterprise and have built a lot of services in Python and Java, and they converge to using similar patterns, regardless of how different the architectures and domains are (web apps, ML research, distributed systems, etc.)

After writing a lot of Python, I was missing a framework that strongly supported some of these patterns formally, and find that this structure lets you make assumptions that can really boost dev experience on long term projects.

Microframeworks are great. They let you get started with a single file of a few lines, but (in my opinion) lack the structure you want on long term projects, working with teams, so you end up making that structure yourself anyway. In doing so, you get a small initial boost in productivity, but at the cost of your productivity in the future.

Mitsuki tries to both allow you to start quick and easy with a single file in a few lines, but also be more friendly to you and your team through time, by giving structure to your development process.

Thus, I made an early version of a framework heavily inspired by Spring Boot. The core idea is that you can do enterprise apps without the enterprise pain, in Python, with high performance.

- Want a simple REST API? app.py with a few lines.

- Want a decent starter with auto-implemented CRUD? mitsuki init to get a starter project with domain classes, services, controllers and repositories.

- Performance? Similar to Express and Spring Boot (in Docker, on an M1 MacBook Pro, 8GB of RAM), out of the box, no configuration needed.

Lightweight

Despite the "fancy sounding" terminology, Mitsuki itself is very lightweight, and only adds a very small overhead (10%) over the components that power it (namely, Starlette and Granian). I don't want to commit to ASGI only, and a future version will likely rewrite this core logic to leverage granian further.

There is a lot of ground left to cover, lots of docs to write, examples to explore, features to expand. I'm also planning to write a few tools that leverage the structure of the framework to increase DX within enterprise teams.

But before any of that, I'm looking for feedback. Yay or nay? :)

Benchmarks

P.S. On the topic of performance and benchmarks, there are a few remarks in the repo's /benchmarks directory. (Or here: https://github.com/DavidLandup0/mitsuki/tree/main/benchmarks)

Yes, most benchmarks are arbitrary, heavily gameable, and your bottleneck is likely going to be your business logic, not the framework, anyways.

Yes, Spring Boot and Elysia will likely have higher ceilings, so running on a stronger CPU will likely change the order of the benchmark.

Yes, there's a million variables that affect these.

Yes, granian is written in Rust, not Python.

The point of the benchmark is threefold:

- This is the sort of experience you get out of the box, on your device and where you'll deploy it (Dockerized on small instance such as through K8s)

- Python web apps can stand shoulder to shoulder with JS/Java performance-wise

- Despite the seeming complexity around dependency injection, state tracking, etc., Mitsuki is pretty lightweight.

I’ve started working on Schema Pilot, an open-source idea for a visual database designer that generates Prisma schema + SQL automatically from a drag-and-drop interface.

Right now it’s very early — mostly the landing page + initial planning for the core engine. But the vision is:

visually create tables & relations

auto-generate FK logic

export clean Prisma + SQL

eventually import existing Prisma schemas

I'm building it in the open and would love feedback, contributors, or anyone interested in the problem space.

Repo: https://github.com/punyakrit/schema-pilot

Happy to answer questions!

It’s obviously easier to start a venture when you already have a clear idea in mind. But in reality, a lot of people that want to be founders are the opposite: they’re eager to start something new, and only then go looking for a real problem to solve. I’ve been asked many times by friends: “I want to build a startup, but I don’t know what problem to solve.”

Yes, there are ideas and complaints scattered across Reddit, Twitter, forums, etc., but there doesn’t seem to be one focused place where pain points and solutions directly meet.

So I built a small MVP: https://www.solvemypainpoint.com/

SolveMyPainPoint lets you: • Submit a pain point in a structured way (what’s the problem, how painful, which category). • See if others share the same issue and how they experience it. • Add or discover existing solutions/products when they exist. • Spot unsolved problems that might be worth building for.

It’s a scrappy side project (white-coat MVP, far from perfect), but I’d love feedback from both people with real frustrations and builders looking for something useful to work on.

If you have a pain point you keep ranting about, please try submitting it. And if you’re a builder, I’d really appreciate thoughts on what would make this genuinely valuable for you (better discovery, tags, subscriptions to topics, etc.).

Happy to answer any questions and very open to criticism and feature suggestions.

Many thanks!

I built RetroAssembly as a classic games cabinet that lives entirely in the browser. It's open source and free to use, and if you'd like you can even host your own instance with Docker (the Docker image is only ~70 MB).

What it does:

- Browse and play a library of classic systems (Nintendo, Sega, Arcade, etc.) from a single place.

- Works across devices, so you can start on one machine, save your progress, and continue on another.

- Automatically fetch game boxarts to enhance the library's visual appeal.

- Smooth keyboard and gamepad navigation.

- Rewind gameplay using a simple shortcut so you can correct mistakes.

Happy to answer questions and hear ideas on how to make it better!

I’ve used Crypto++ for a long time, but I wanted newer algorithms and a more regular release cycle. To solve that, I started maintaining cryptopp-modern, a fork based on Crypto++ 8.9.0.

The aim isn’t to redesign Crypto++, but to offer a mostly drop-in option for existing users with a few modern additions.

Highlights

Based on Crypto++ 8.9.0, same CryptoPP namespace and overall API style

Adds BLAKE3 and Argon2 (RFC 9106) on top of the existing primitives

Modernised CMake build (presets, find_package, exported targets) plus updated GNUmakefile

CI across multiple platforms

Documentation site with API reference, guides, examples, and migration notes

Most Crypto++ 8.9.0 code should compile and run with little or no change. The main differences are version macros and the build system, which are documented.

The target audience is people who are already comfortable with Crypto++ but want BLAKE3/Argon2 and a more active release cadence.

Repo: https://github.com/cryptopp-modern/cryptopp-modern

Docs: https://cryptopp-modern.com/

I’d really appreciate feedback from:

People running Crypto++ in production: is this useful, and what would make migration easier?

People with strong views on C++ crypto library design, misuse resistance, and versioning: what would you change while this is still young?

Hi HN,

I built Aion, an “AI longevity coach” that integrates three data sources that are usually siloed:

Wearable data (e.g., Whoop, Oura, Apple Health: sleep, HRV, strain)

Blood tests (hormones and basic longevity markers)

Simple phone-based facial scans

The aim is to provide a clearer picture of energy, hormones, sleep and recovery over time and to translate this into straightforward daily recommendations (sleep timing, caffeine window, training intensity, light exposure), rather than just another metrics dashboard.

Link: https://www.aionlongevity.com/ Demo video: https://www.youtube.com/watch?v=BR9AScuVGjA&feature=youtu.be

A 7-day free trial is available.

I would appreciate feedback on:

Whether this addresses a real need or feels redundant with existing tools

What you would require (export options, transparency, controls) to consider using a product like this

Thank you, Neven

Built this because AI coding shouldn't cost hundreds per month. It's Cline with free Open Source and Deca models plus cost tracking for when you need GPT-5/Claude. The free tier handles 70% of daily coding.

Try it: https://github.com/GenLabsAI/Agentica/releases/tag/v0.0.1

You can use a demo email and password for testing: (demo: [email protected] / agentica@123)

Looking for feedback on where the free models fall short. Building sustainable AI tools for developers.