DEV Community: Puneet-Kumar2010

Crowdwide Is Now Public for Testing 🚀

Puneet-Kumar2010 — Sun, 20 Sep 2026 04:34:27 +0000

So yeah... Crowdwide is finally public.

I've been working on it for more than 15 days before the first deployment, and after a lot of debugging, fixing things, breaking things again, and dealing with some really annoying email errors, I finally got it to a point where I can let other people use it.

The first public deployment was on September 9, 2026 at 11:13 AM (New Delhi time).

But it's still a test version.

What is Crowdwide?

Crowdwide is a social platform where people can create their own communities.

You can create a community and use it for things like:

Posts
Articles
Polls
Comments and replies
Media
Moderation
Community roles
Guidelines
And other community management stuff

The main idea is that you don't just have a profile and post into one giant feed. You can actually create a place around a topic or interest and build a community there.

Why am I building it?

One thing I've been thinking about while building Crowdwide is how new users and communities get discovered.

On many platforms, once a community or creator becomes big, they naturally get a lot more visibility.

I wanted to experiment with something different.

One of the ideas I'm working with is giving around 35–40% of the feed's visibility to newer users and community content, while the remaining part can contain established communities, other content, and things that are already getting attention.

This isn't a fixed promise that every new user will get exactly 35–40% of impressions. It's more of a direction for how I want to experiment with the feed.

And honestly, I don't know yet how well it'll work.

That's one of the things I want to find out during testing.

Now I need real people to use it

Until now, most of the testing was basically me testing my own platform.

And that's not enough.

I can click through every feature and think everything works, but another person will use it completely differently and immediately find something I never noticed. 😭

So during this test, I want people to actually:

Create communities
Join communities
Make posts
Write articles
Create polls
Comment
Moderate communities
Try different features
And hopefully break something

If something breaks, that's useful information for me.

What am I going to work on now?

The public test is planned to continue until September 30, 2026.

During this time, I'll mainly be working on things like:

🐛 Fixing bugs people find
✉️ Improving the email system and its UI
🎨 Improving the website UI
📝 Improving the write-ups and information on the website
📊 Showing proper real platform statistics
⚡ Optimizing the site
🎞️ Adding GIFs to comments and DMs
💾 Extending the storage clusters
📱 Making the site work even better on different devices

The site is already responsive, but there's always something that can be improved.

The email problem...

Probably one of the more annoying things I had to deal with recently was email.

The website itself could be working, but then verification emails would fail.

So I had to spend time figuring out what was actually wrong with the mail setup and getting it working properly.

It's fixed now, thankfully. 😭

And honestly, this is one of the reasons I want actual people testing the platform.

There will always be things I haven't thought about.

What about monetization?

Not yet.

Monetization is something I want to work on later if Crowdwide gets enough users and communities.

One of the things I'd like to eventually provide is monetization for communities/creators, especially people who are just starting out.

But right now I'm not trying to rush into that.

First I want to make the actual platform good.

What happens on September 30?

This is important.

The current version is a test version, so the data created during the public test won't be kept forever.

On September 30, the plan is to delete the test data.

After that, I'll start with a clean database and publish the stable version.

So if you create an account or community during the test, just keep in mind that it's part of the testing phase.

So... want to test it?

If you want to try it, it's here:

https://www.crowdwide.run.place/
https://github.com/DeveloperPuneet/Crowdwide

Create a community.

Make some posts.

Try the features.

And if you find something broken or something that just feels weird, let me know.

Honestly, finding bugs is probably more useful to me right now than compliments. 😂

I've spent the last couple of weeks building Crowdwide.

Now I want to see what happens when other people start using it.

Public testing is officially on. 🚀

Let's see how this goes.

I’m Building Crowdwide — A Social Platform Where Smaller Communities Get a Chance

Puneet-Kumar2010 — Sun, 13 Sep 2026 15:50:51 +0000

So... What Actually Is Crowdwide? 🚀

If you've been following my recent posts, you might have seen that Crowdwide just became the KODA ONLINE FEST Season 2 Champion. 👑

Puneet-Kumar2010

Sep 13

🚀 Crowdwide Just Became a KODA Season 2 Champion 👑

#showdev #webdev #hackathon #buildinpublic

2 min read

But there's one thing I realized I never properly explained here:

What actually is Crowdwide?

I've mentioned it a lot.

I've talked about winning KODA.

I've talked about Harun being the first person to test it.

I've talked about building it.

But I've never really sat down and introduced the project itself.

So... here we go.

🌐 Meet Crowdwide

Crowdwide is a social media and community platform I'm building around one simple idea:

Smaller communities should have a chance to grow without needing to already be huge.

A lot of platforms naturally create a cycle where the communities that already have a massive audience get even more visibility.

If a community already has thousands of members, it's easier for it to attract thousands more.

But if you're starting with 10 people?

You're fighting for attention against communities that already have thousands.

I don't really like that.

I don't want someone's reach or growth to come at the cost of everyone else being able to discover something new.

That's one of the main reasons I'm building Crowdwide.

🎯 The Core Idea

Crowdwide isn't supposed to be:

"Build a community and hope someone discovers it."

I'm trying to build a platform where discovery itself is designed to give smaller communities a chance.

The goal is to create an ecosystem where a community doesn't need to already be massive to have an opportunity to reach new people.

That doesn't mean every small community should automatically become popular.

It means being small shouldn't automatically mean being invisible.

That's the distinction I'm trying to build around.

🧩 It's More Than Just Communities

Crowdwide isn't only a place to create a community.

I'm trying to build a complete social platform around it.

Some of the features I'm working on include:

👥 Communities
🔒 Private communities
📝 Posts
📚 Articles
💬 Group chats
🛡️ Community moderation
👤 User profiles
🔍 Discovery
📈 Community growth
💰 Future monetization features
🤖 Recommendation/algorithmic systems
And a lot more that I'm still building

The idea is that communities shouldn't have to leave the platform just because they want to do something different.

You should be able to create a community, manage it, communicate with its members, publish content, and eventually grow it into something much bigger.

🏗️ It's Still Under Development

And this is important.

Crowdwide is currently an alpha.

Very much an alpha. 😭

I've built a huge amount of the UI and the platform structure, but there are still many things that aren't finished or properly connected.

So if you visit the current version and think:

"Wait... why can't I create an account?"

That's intentional.

⚠️ Please don't try to create an account or expect your data to persist.

The current deployment is primarily there for testing and development.

The authentication/account system isn't ready for public use yet, and data may be cleared or not persist while I'm working on the application.

I'd rather be transparent about that than pretend the platform is production-ready when it isn't.

🔐 Security Is Something I'm Taking Seriously

One thing I'm particularly interested in with Crowdwide is security.

This isn't my first attempt at building a social platform.

A previous social media project I built...

didn't even survive a week. 😂

But honestly?

That project taught me a lot.

It showed me how many things you don't think about when you first start building a platform where users, accounts, communities, and content all interact with each other.

That failure became a pretty useful lesson.

So while building Crowdwide, I've been trying to take those lessons and apply them from the beginning.

I've added a lot more security considerations and protections than I did in my earlier projects, and I'm continuing to learn and improve them as Crowdwide grows.

I'm definitely not going to claim that I've somehow solved security forever.

I haven't.

But I'm much more conscious of it now.

And that's probably one of the biggest differences between the projects I used to build and Crowdwide.

🧠 Why I'm Building It

The technical side is fun.

Building the UI is fun.

Writing the backend is fun.

Figuring out how different systems connect is fun.

But the main reason I'm building Crowdwide is the idea behind it.

I want to experiment with what a community platform could look like if discovery wasn't completely dominated by existing size.

What happens if a small community actually gets opportunities to be discovered?

What happens if people can find interesting communities before they've already become huge?

What happens if growth isn't simply:

big → bigger → biggest

but instead there's actually room for:

small → discovered → growing

That's the experiment.

And Crowdwide is my attempt at building it.

🏆 Then Somehow... It Became a Champion

The funny part is that I originally wasn't even planning to enter Crowdwide into a contest.

I had only hosted it for testing.

Then Harun found it, became the first person to test it, reported bugs, and suggested that I submit it to the KODA Code Jam.

I submitted the alpha.

And later, I found Crowdwide sitting in the KODA Hall of Champions as the Season 2 Champion. 👑

You can read the full story here:

Crowdwide Just Became a KODA Season 2 Champion 👑

Harun also wrote about Crowdwide being the first submission to the KODA Code Jam, which was pretty crazy to see:

The First Legend Has Entered the Arena: CrowdWide Just Submitted to the KODA Code Jam

And honestly, that whole sequence of events still feels a little unreal.

🚧 What's Next?

The championship was cool.

Really cool.

But Crowdwide is nowhere near finished.

There's still a massive amount of development ahead.

I want to finish the core systems, properly implement authentication, improve security, build out moderation, finish the community experience, develop the discovery algorithm, work on monetization, and eventually make the platform something people can actually use reliably.

Right now, I'm still in the stage of:

Build → Break → Learn → Fix → Repeat.

And that's okay.

I'd rather build it properly than rush it just because someone gave it a title.

🚀 So That's Crowdwide

It's not another finished social network claiming to have everything figured out.

It's an experiment.

It's a massive project I'm building because I think there's an interesting problem worth exploring:

Can a social platform give smaller communities a real opportunity to be discovered without requiring them to already have an audience?

I don't know exactly where Crowdwide will end up.

But I'm going to find out.

For now, it's still under development.

And if you visit the alpha, please don't create an account yet. 😭

I'll let you know when it's actually ready for people to start using it properly.

Until then...

I'm still cooking. 👨‍🍳🔥

👑 Crowdwide

Community & Social Platform

Build your community. Grow it. Manage it. Eventually monetize it.

But don't let size decide who gets discovered.

🚀 Crowdwide Just Became a KODA Season 2 Champion 👑

Puneet-Kumar2010 — Sun, 13 Sep 2026 15:34:20 +0000

Honestly, I didn't expect this at all.

Around 4–5 days ago, I hosted Crowdwide mainly for testing.
It wasn't something I was actively promoting, and I definitely wasn't thinking about entering it into any contest.

Then @koda2026 found it on DEV.to.

He became the first person to actually try out Crowdwide and even reported some bugs he found while testing it.

And yes — some of those bugs were completely expected because the application wasn't actually ready for public account creation yet. 😭

At that point, I still hadn't completed the proper authentication and credentials flow. I was using Postman to test the backend requests while continuing to build the actual platform.

Then Harun suggested something I honestly hadn't considered:

"You should submit Crowdwide to KODA ONLINE FEST."

So... I did.

I wasn't expecting much from it.

🏆 And Then This Happened...

I checked the results and went to the Hall of Champions.

And there it was:

👑 Crowdwide — S2 Champion

Season 2 ChampionCrowned

Crowdwide — Community & Social Platform

The description says:

Build your community, grow it, manage it, and monetize it—with an algorithm that doesn’t let only the biggest communities win. 🚀

I genuinely just stared at the screen for a moment.

I WON. 😭🔥

A project that I had only recently put online for testing somehow ended up becoming the KODA ONLINE FEST Season 2 Champion.

🛠️ But Crowdwide Isn't Finished Yet

This is probably what makes this achievement even more interesting to me.

Crowdwide is a massive project, and although I've already built a huge part of the UI and the overall platform structure, there is still a lot left to do.

Authentication, backend systems, testing, moderation, community features, monetization, and many other parts still need to be completed and properly connected.

So I don't see this award as the finish line.

I see it as motivation to actually finish what I started.

Right now, Crowdwide is still a work in progress.
But knowing that the idea and the work I've already put into it were enough to earn a championship gives me even more reason to keep building.

👊 A Special Thanks to Harun

I especially want to thank Harun.

He was the first person to actually test Crowdwide, report bugs, and then suggest that I submit it to KODA.

If he hadn't suggested it, I probably wouldn't have entered the contest in the first place.

So seriously, thank you Harun. 👊

I'll definitely remember this when Crowdwide is finally complete.

👑 Champion Status Forever

And apparently, KODA gives me:

👑 Champion Status Forever

That's something I absolutely didn't expect when I first hosted Crowdwide just for testing.

It's a pretty crazy feeling seeing a project that is still under development sitting in a Hall of Champions.

But the work isn't over.

There is still a lot to build.

This championship isn't the end of Crowdwide.

It's the beginning of the next phase. 🚀

Crowdwide — KODA ONLINE FEST Season 2 Champion 👑

Now back to cooking. 👨‍🍳🔥

And Harun...

When the full version is ready, you're definitely going to be one of the first people testing it again. 😂👊

From VibeConnect to CrowdWide: Building My Own Social Platform

Puneet-Kumar2010 — Sun, 13 Sep 2026 06:20:32 +0000

A while ago, I started building a social media platform called VibeConnect.

It was mostly a learning project. I was experimenting with authentication, posts, communities, profiles, and other social-media features while learning how everything worked.

But VibeConnect had a lot of problems.

Security wasn't strong enough, several important features were missing, there was no proper 2FA, media handling was incomplete, and many parts of the platform were still unfinished.

Instead of trying to keep patching the same project, I decided to start again — this time with a much bigger goal.

That's how CrowdWide started.

Why I Started CrowdWide

One thing I've noticed while building and sharing projects is that getting people to discover your work can be surprisingly difficult.

When you post something on an existing social platform, larger accounts and established communities often already have a huge audience.

That doesn't necessarily mean their content is better.

It just means they already have momentum.

As someone who builds projects while learning, I've experienced this myself. You can spend days or weeks working on something, share it online, and barely get any attention.

Meanwhile, an established account can post something similar and immediately reach thousands of people.

That made me think:

What if a social platform gave newer creators and smaller communities a better opportunity to be discovered?

That question eventually became CrowdWide.

What Is CrowdWide?

CrowdWide is a social platform I'm building around communities, creators, and discovery.

The idea isn't to guarantee that every post becomes popular.

Instead, I want community size to be less of a barrier to getting that initial exposure.

CrowdWide is intended to support different kinds of creators and communities:

Developers
YouTubers
Bloggers
Artists
Writers
Project builders
Personal blogs
Article creators
Online communities
People documenting their learning journey

The goal is to make discovery more accessible without removing the importance of good content.

Experimenting With the Feed Algorithm

One of the ideas I've been experimenting with is how the initial feed distribution works.

My current experimental split is:

40% — new users and smaller/new communities
55% — established communities
5% — viral or trending content

This isn't meant to be a permanent rule.

It's an experiment.

The important idea behind it is that community size shouldn't completely determine whether something gets seen.

A post from a small community should have an opportunity to prove itself.

If people interact with it positively, it can gain momentum and receive more distribution.

So instead of:

Big community → automatically gets more reach

I'm trying to move toward:

Initial opportunity → people respond → content earns more reach

I'm still working out the exact algorithm, and I expect this part to change significantly as I get real usage data.

What I've Built So Far

CrowdWide has grown quite a lot from the original idea.

Some of the things I've implemented include:

Posts and Content

Text posts
Articles
Polls
Drafts
Scheduled publishing
Media uploads
Alt text
Hashtags
Mentions
Quote posts
Linked post replies
Content warnings
Post editing and deletion

Engagement

Likes
Comment likes
Reactions
Bookmarks
Sharing
Nested replies
Threaded discussions
AJAX interactions without full page reloads

Communities

Public and private communities
Join requests
Community roles
Moderators
Banned words
Post approval
Pinned posts
Community guidelines
Community feeds

Profiles

Profile banners
Avatars
Bios
Links
Followers and following
Saved posts
Activity
Likes
Comments
Privacy controls

Discovery

I've also been working on the discovery side of the platform:

Personalized feeds
New-content discovery
Viral posts
Trending hashtags
Recommended users
Recommended communities
Search filters
RSS support
An API for posts

There is also an unanswered-post discovery filter so people can potentially find posts that haven't received a response yet.

Security Has Been a Major Focus

After working on VibeConnect, I realized how important it is to think about security early rather than treating it as something to add at the end.

CrowdWide currently includes things such as:

Email verification
Password reset
Login lockouts
TOTP-based 2FA
Recovery codes
Session/device management
CSRF protection
Security headers
Rate limiting
Account suspension
Reports and moderation queues
Audit logs
Data export and deletion

I'm also trying to make security-related actions visible and understandable to users rather than hiding everything behind the scenes.

Moderation Is Another Big Part

A social platform isn't just about building features that let people post.

You also need systems for dealing with abuse, spam, inappropriate content, and community-level moderation.

CrowdWide already has reporting and moderation infrastructure, but there's still a lot I want to improve.

Some of the things I'm working toward include:

Moderation appeals
Evidence attachments
Temporary mutes
Better CAPTCHA and abuse controls
Stronger spam detection
Better moderation tooling
More comprehensive automated testing

I want moderation to be useful without making communities feel overly controlled.

What Still Needs to Be Done

Despite having a large feature set already, CrowdWide isn't finished.

Some of the major things still on my roadmap are:

Browser push notifications
Link previews
Richer article editing
Media captions and transcripts
Moderation appeals
Better spam detection
More automated integration tests
End-to-end signup and posting tests
Structured logging
Monitoring and alerts
Backup and restore testing
CI/CD
Staging infrastructure
Virus scanning for uploads
API documentation
More admin functionality

And, of course, there are probably bugs I haven't discovered yet.

The Testing Problem

One of the hardest parts of building something like this isn't necessarily writing the code.

It's testing it properly.

There are a lot of interactions between different parts of a social platform.
Also, I have created different roles like admin, moderator and user...
by default you will have role user. To get role moderator just mail on the contact email developerpuneet2010@gmail.com and after verification you will get role moderator and you can access the panel but if you break the rules that role will be deleted

For example:

Account → Community → Post → Comment → Notification → Moderation

A change in one area can unexpectedly affect another.

Right now, I'm working toward having much stronger automated tests before opening the platform to more people.

I'd rather discover problems during testing than after a public release.

What's Next?

My current plan is roughly:

Finish the remaining core features
Complete the admin and moderation systems
Add more automated tests
Perform manual testing
Set up staging
Get a few developers to test it
Fix the issues they find
Release a public beta
Monitor the platform
Continue improving it
Eventually move toward a stable release

I'm deliberately not trying to rush the public launch.

A social platform needs to be reliable, secure, and reasonably polished before putting it in front of a larger audience.

From a Learning Project to Something Bigger

The biggest difference between VibeConnect and CrowdWide isn't just the number of features.

It's how I'm approaching the project.

VibeConnect was primarily about learning how to build a social platform.

CrowdWide is about trying to solve a problem that I've personally experienced while building and sharing projects.

I'm still learning a lot while developing it.

There are plenty of things I don't know yet, and I'm sure the architecture and algorithms will change as the project grows.

But that's part of the process.

I'm building it, breaking things, fixing them, and learning along the way.

Where CrowdWide Goes From Here

I don't know exactly what CrowdWide will look like a year from now.

The feed algorithm will probably change.

Some features will probably be removed.

New ones will probably appear.

And I'm sure I'll rewrite parts of the code that I currently think are perfectly fine. 😅

For now, my goal is simple:

Build the best version of the idea I can, test it properly, and see whether it actually helps smaller creators and communities get discovered.

That's where CrowdWide is today.

And this is just the beginning.

Someone Called Me the Founder of Rizzzler… So I Had to Do Something 😂

Puneet-Kumar2010 — Wed, 09 Sep 2026 13:56:38 +0000

Okay! this is probably one of the funniest things that has happened with Rizzzler recently...

A while ago... I wrote an article about my journey building Rizzzler.

It was basically me talking about the whole thing... starting the project, getting the first users, building features, realizing that people liking something doesn't necessarily mean they'll come back, and all the other lessons I've learned while building it.

Pretty normal builder stuff...

Then one day, I found an article on another website that was based on my story.

And I started reading it!

And then I realized...

I'm literally reading my own story. 😭

Not my article.

Someone else's article!!

About my journey.

And then I reached the part where they called me:

“The founder of Rizzzler.”

BROOOOOOHH... 💀

I don't know why, but that hit DIFFERENT!!!!

My aura went:

+1000++++
+100
+100
+100

Every. Single.. Second...

For the entire duration of that article, I was basically sitting there like:

“The founder of Rizzzler…” 😎

I had never really used “Founder of Rizzzler” myself before.

I was always just:

“Yeah, I built Rizzzler.”

But someone else wrote “founder” so confidently that I was like:

Well... they're not wrong. 😂

I continued reading my own lore like I was discovering a character in a documentary.

“The founder started Rizzzler…”

Me: 👁️👄👁️
Wait who's this guy?
Also me: Oh. That's me. 💀

Then I closed the article.

Aura immediately returned to normal.

Back to reality. 😂

So I wanted to give that article a spotlight

I genuinely liked seeing someone outside of my own posts write about the Rizzzler journey...

I wanted to put the article somewhere on the website.

But I didn't want to make some boring little page called Press

So I thought:

Why not make a place specifically for stories about Rizzzler?

And that's how Rizzzler Spotlight Stories was born.

👉 https://www.rizzzler.work.gd/spotlight-stories

I've added the articles and stories I've found so far, and I built it so I can add new ones directly from the admin panel.

So if you've written about Rizzzler, mentioned Rizzzler somewhere, or come across an article about Rizzzler that I haven't found yet:

Tag/mention me! 👀

Or if it's published somewhere else, send it to:

📩 developerpuneet2010@gmail.com

I'll happily add it to the Spotlight Stories section...

Basically, one person wrote about my project...

and I responded by building an entire feature for articles about my project.

Very normal behavior. 👍

And now… I'm looking for moderators 👀

I'm also thinking about opening up a few volunteer moderator spots for Rizzzler.

Nothing insanely complicated.

You wouldn't need to sit there moderating 24/7 like you're running the internet. 😂

The idea is mainly to help with:

👀 Checking users and keeping an eye out for obvious bots/spam
🧹 Helping keep the community clean and friendly
💬 Interacting with users and leaving encouraging comments
🚩 Flagging anything that needs my attention
💡 Sharing feedback and ideas for improving Rizzzler

And if you're interested in helping with the social side too, I can also give moderators access to Rizzzler's social media handles so they can help post updates, share interesting things happening on the platform, and help get more people involved.

Basically:

Help the community → interact with people → spot problems → share ideas → help Rizzzler grow.

If you're interested in volunteering as a Rizzzler moderator, drop a comment or message me. 👀

Rizzzler is still growing, and I'm still figuring things out as I go.

Sometimes that means building a new feature.

Sometimes that means looking for people to help.

And sometimes...

it means reading an article about your own life and discovering that apparently you're the founder. 💀

Just Puneet things.

😂🚀

I Didn’t Have a Developer Website, So I Built One.

Puneet-Kumar2010 — Tue, 08 Sep 2026 04:50:51 +0000

For a long time, I published most of my articles on DEV.to.

Not because I had some big strategy behind it.

I simply didn't have a website of my own.

DEV.to was convenient. I could write something, publish it, and put it in front of other developers.

But eventually I started thinking:

What if I had my own place for all of this?

My projects.
My articles.
Things I've built.
Things I've broken.
Things I've learned.

So I decided to build one.

Meet Devlogr 🚀

Devlogr is my personal developer portfolio and blog.

👉 https://www.devlogr.run.place/

The idea is pretty simple:

A place where I can document what I'm building and learning, while also having a home for my projects and developer profile.

The name comes from Dev + Log.

Basically, a log of my journey as a developer.

What does it have?

I wanted it to be more than just a page saying:

"Hi, I'm a developer. Here are my skills."

So I built it around the things I actually want to show.

📝 Articles

This is where I'll be writing about things I build, problems I run into, experiments, lessons learned, and whatever else seems worth documenting.

I'll also be moving some of my older articles here.

🚀 Projects

My projects have their own place instead of being buried somewhere in a GitHub profile.

The goal is to show not just what I built, but eventually more about why I built it and what I learned from it.

🐙 GitHub integration

I also wanted my projects and GitHub activity to connect naturally with the site instead of manually updating everything every time.

So parts of the site use GitHub data to keep things more dynamic.

🔍 SEO

Since this is my own website, I didn't want it to just exist at a URL that nobody can find.

So I also spent time making it properly SEO-ready:

Dynamic page metadata
Canonical URLs
Sitemap
robots.txt
Open Graph previews
X/Twitter cards
Structured data
Article metadata
Semantic HTML
Image optimization
Internal linking
Mobile optimization
Crawlability and indexability

There is obviously still a lot to learn about SEO, but I wanted to start with a solid foundation.

Why not just keep using DEV.to?

I'm not stopping.

I actually think platforms like DEV.to are great for reaching other developers.

But there's a difference between having an audience somewhere and having a home of your own.

So I'm thinking about it like this:

Devlogr → my home

DEV.to → distribution/community

I'll continue sharing articles on DEV.to, but Devlogr will be the original home for my writing.

That also means I can experiment with the website however I want.

No waiting for someone else's feature.

No worrying about how the platform changes.

It's mine.

Building it was also the point

One of the reasons I wanted to build Devlogr was simply to learn.

There are plenty of things I could have used an existing solution for.

But building it myself meant I had to think about:

Architecture
Routing
Content management
UI/UX
SEO
Performance
Deployment
Security
Integrations
And all the weird little problems that appear once something is actually running.

And honestly, those problems are probably more valuable than the finished website.

Because every time something breaks, there's something new to learn.

What's next?

Devlogr is definitely not "finished."

I want to keep improving it as I use it.

Some things I'd like to explore:

Better article discovery
More project details
Improved search
More developer-focused features
Better analytics
More integrations
And probably a bunch of ideas I'll come up with after using it for a while 😅

For now, though, I'm happy to finally have a place of my own.

So... welcome to Devlogr 👋

I started it because I didn't have a developer website.

Now I do.

And from here, I'll be documenting what I build, what I learn, and occasionally what I completely break.

Building. Breaking. Learning. Repeat.

👉 Devlogr: https://www.devlogr.run.place
👉 Github source code: https://github.com/DeveloperPuneet/Devlogr

If you're also building your own little corner of the internet, I'd love to hear about it.

Hello

Puneet-Kumar2010 — Sun, 06 Sep 2026 11:28:50 +0000

I don't have a technical tutorial, project announcement, or big lesson to share today.

I just wanted to say hello.

Sometimes not every post needs to teach something. Sometimes it's just nice to start a conversation.

So...
😐
How are you?

I Built a Link-in-Bio Platform… Then I Asked: “Why Would Anyone Come Back?”

Puneet-Kumar2010 — Wed, 02 Sep 2026 03:23:40 +0000

On July 11, 2026, I started building a project inspired by link-in-bio platforms.

The idea was pretty straightforward:

Create a profile → customize it → add your links → share it.

So I built Rizzzler.

And right now, it has 11 users.

Yep.

11 😂

Not exactly the kind of number you'd put on a startup pitch deck.

But those 11 users actually made me think about the project in a completely different way.

The problem I noticed 🤔

I started looking at how people were using Rizzzler.

And I noticed something:

People would create their profile...

Then disappear.

Some wouldn't come back for a week.

Some wouldn't even check the app for weeks.

And eventually I realized something obvious.

Why would they?

Rizzzler was primarily a profile website.

Once you've created your profile and shared your link, what reason do you have to open it again?

You don't.

That got me thinking:

What else can we actually do with a profile?

I didn't want Rizzzler to become something people set up once and completely forget about.

I wanted the profile to actually do something.

And that's where I got a pretty crazy idea.

What if Rizzzler became more than a profile?

I've used services that let you log into other applications using their account.

For example:

That got me thinking:

What if Rizzzler could do something similar?

Instead of Rizzzler only being a place where you create a profile...

What if developers could use Rizzzler as an identity provider?

And suddenly I had a new idea:

That was probably the craziest idea I've had for this project so far.

And I decided to build it.

I built my own OAuth 2.0 system 🔐

I started building the OAuth 2.0 mechanism, the developer-side integration, and the documentation.

I also created a developer docs page so developers can understand how to integrate Sign in with Rizzzler into their applications.

I've tested the mechanism locally, but there's an important distinction:

It hasn't been properly tested by a real third-party application yet.

So I'm definitely not going to call it some battle-tested authentication system.

The core is built.

The docs are there.

Now I want people to actually try using it.

If you're a developer and this sounds interesting, I'd genuinely love for you to integrate it into a small project and see how it goes.

Try it.

Break it.

Tell me what's confusing.

Report bugs.

That's exactly what I need right now.

Because there's a huge difference between:

"It works on my local machine."

and

"Someone else actually integrated it and it works."

😂

And I built a security dashboard too

If I'm going to let Rizzzler handle authentication, I don't want users to have zero visibility into where their account is being used.

So I also started building a security dashboard.

The idea is that users can see where they've used their Rizzzler account to sign in or register.

They can manage those connections and remove them when they want.

I want users to have actual visibility and control over their authentication activity.

It's still something I'm improving, but I think this is an important part of making the whole idea useful.

Then I had another completely stupid idea 😂

While I was working on all of this, I was also experimenting with AI-generated emails.

And instead of making another boring:

"Here is your weekly Rizzzler activity."

email...

I thought:

Why don't I let AI roast your profile?

💀

So I built a system that generates funny emails based on a sample representation of a Rizzzler profile.

The AI basically looks at the profile information available for the roast and turns it into an absolutely unhinged little comedy session.

You might get something like:

"Bruh, your bio looks like a cry for help."

And then it just keeps going.

It can roast things like having an absurd number of links, an overly dramatic bio, questionable profile choices, or basically anything that can be turned into a harmless joke.

The goal is simple:

Make the email something you actually want to open.

Instead of:

"Your weekly report is ready."

You get:

"Your internet persona is currently held together by vibes."

😭

But what about privacy? 🔐

This is important.

NO — I'm not sending your private/user data to the AI just to roast you.

The system uses a sample/anonymized profile representation for generating the roast rather than handing over someone's private account information.

I wanted to make this clear because the moment you hear:

"AI + your profile + email"

it's completely reasonable to ask what data is being sent where.

Privacy matters, especially when authentication and user accounts are involved.

And now the AI emails are actually live

After experimenting with it for a while...

It's finally working. 😂

There's roughly a 55% chance on any given day that you'll receive one of these AI roast emails.

So you might randomly open your inbox and see:

"Bruh your bio looks like a cry for help."

And then spend the next minute getting roasted by an AI.

I genuinely don't know whether users are going to love this or immediately unsubscribe.

But that's part of the experiment.

So what is Rizzzler becoming?

This is the funny part.

I started this project thinking:

"I'm going to build a link-in-bio platform."

Then I noticed:

"People don't really have a reason to come back."

Then I asked:

"What else can a profile actually do?"

And now I'm experimenting with:

🔐 OAuth 2.0 / Sign in with Rizzzler
👨‍💻 Developer authentication
📚 Developer documentation
🛡️ User security & connected-app management
🤖 AI-generated emails
😂 AI profile roasting
👤 The original customizable profile system

It's turning into something quite different from what I originally planned.

And honestly...

I like it.

Am I overengineering an 11-user project?

Probably. 😂

But I think that's one of the most fun parts of building things.

I could have looked at 11 users and decided:

"Nobody is using this. Forget it."

Instead, I started asking why.

Why don't they come back?

What would make Rizzzler useful after creating a profile?

What could a profile become?

And that question led me to something I never expected to build:

an identity/authentication system.

I don't know if this direction will work.

Maybe nobody will use Sign in with Rizzzler.

Maybe developers will find the OAuth integration annoying.

Maybe everyone will unsubscribe from my AI roast emails. 💀

But I won't know until I actually put it out there.

So... try it 👀

If you're a developer, try integrating Sign in with Rizzzler.

I'd genuinely love feedback from people who aren't me testing it on localhost.

If something breaks, report it.

If something is confusing, tell me.

If the whole idea is stupid...

Well...

tell me that too. 😂

And if you use it in an actual project, I'd absolutely love to hear about it.

Because right now, Rizzzler isn't some massive platform.

It's a small project with 11 users, a bunch of experiments, and a ridiculous amount of code.

But that's exactly what makes it fun to build.

Let's see what it becomes. 🚀

What do you think?

Is turning a link-in-bio platform into an OAuth/identity platform actually a good idea?

Would you use Sign in with Rizzzler in your project?

And most importantly...

Would you voluntarily receive an email where an AI roasts your profile? 💀

Wow, We Gained 10+ Users 😂 — So I Kept Updating Rizzzler

Puneet-Kumar2010 — Mon, 31 Aug 2026 11:45:53 +0000

A little while ago, I wrote about launching Rizzzler, my open-source project.

At that point, 7 users had signed up in my another post

Now?

We're at 11 users. 🎉

Okay, technically that's only 4 more users...

But still — 10+ users! 😂

For a small project built and deployed with basically no marketing budget, I'm honestly pretty happy about it.

But the more interesting part isn't the number.

It's what happened after people started giving feedback.

Instead of just adding random features, I started using that feedback to actually change Rizzzler.

And here's what has changed.

📚 I Added a Docs Page

Rizzzler now has an actual documentation page.

👉 Rizzzler Docs

This should make it easier for new users to understand how everything works instead of having to figure things out themselves.

It's a small thing, but definitely something I should've had earlier.

🎨 4 New Themes

One of the things I really enjoy working on in Rizzzler is the visual side.

So I added four new themes:

Bubble Pop

Playful cartoon styling, candy colors, bouncy backgrounds and goofy kid-energy vibes.

🌪️ Sticker Storm

A sticker-packed chaos theme with floating emoji bursts, confetti motion, playful gradients, and animated bouncy energy.

🤪 Sticker Chaos

Basically Sticker Storm turned up to 11.

Even more emoji, sticker clusters, zoom bursts and maximal playful motion.

⚡ Neon Pulse

A completely different vibe.

Dark cyber glow, electric cyan-magenta gradients, dramatic contrast and nightlife energy.

I wanted Rizzzler profiles to feel more customizable instead of everyone ending up with the same visual experience.

✍️ Your Bio Isn't Just Plain Text Anymore

I've also added formatting options to bios.

You can now use things like:

highlighted text

bold

italic

So instead of having a boring block of text, you can actually give your profile some personality.

Because apparently even bios need ✨drama✨.

📧 Phone Number → Public Email

I changed the profile field from Phone Number to Public Email.

The idea is pretty simple: a public profile shouldn't necessarily need to expose someone's phone number.

📏 Better Profile Field Limits

I've also tightened the character limits across profile fields.

The goal is to keep profiles clean, focused and readable.

Field Limit
Bio 250 characters
Public Email 120 characters
Location 80 characters
Profession 80 characters
Hero Eyebrow 60 characters
Moment Titles 60 characters
Moment Blurbs 180 characters

Small change, but it makes profiles much easier to keep visually consistent.

📝 Showcase Text Is Finally Editable

Previously, some of the showcase text was basically fixed according to the theme.

Now you can customize it.

You can edit things like:

Hero eyebrow
Moment 1 title
Moment 2 title
Moment 1 blurb
Moment 2 blurb

So themes control the style rather than completely controlling what your profile says.

That's a much better separation.

🎵 You Can Upload Audio

Another addition:

You can now upload audio for your showcase profile.

I wanted profiles to feel more like an actual personal space rather than just another static profile page.

🔐 Security Improvements

I've also spent time improving Rizzzler's security.

There are now better protections around suspicious activity and abusive/repeated requests.

This is one of those things users probably won't notice when everything is working correctly...

Which is kind of the point. 😅

🛠️ Improved Admin Panel

The admin panel has also received some improvements.

It's easier to monitor what's happening on the platform and manage things behind the scenes.

As Rizzzler grows, having decent internal tools becomes increasingly important.

Even if there are only 11 users right now. 😂

7 → 11

Going from 7 users to 11 users isn't some crazy startup growth story.

I'm not going to pretend it is.

But for me, it's meaningful.

Because these aren't just numbers in an analytics dashboard.

People actually found the project, signed up, tried it, and gave feedback.

And that feedback turned into real changes.

That's probably the biggest lesson I've learned from building Rizzzler so far:

Don't just build more. Build what the users are telling you they need.

The project is still tiny.

The user count is still tiny.

And there's still a lot I want to improve.

But it's moving.

7 → 11.

Let's see where it goes next. 🚀

Try Rizzzler

🌐 Website: https://www.rizzzler.work.gd
📚 Docs: https://www.rizzzler.work.gd/docs
💻 Source Code: https://github.com/DeveloperPuneet/Rizzzler-Stable

And yes...

I'm still building this thing. 😭

I Was Tired of Configuring Every LLM Parameter, So I Built Tensorless 🤯

Puneet-Kumar2010 — Thu, 27 Aug 2026 10:39:12 +0000

About a year ago, I was learning PyTorch.

I was learning about model training, transformers, language models, tokenization, architectures, and all the other things that come with building models.

And honestly?

There were a LOT of parameters.

d_model

hidden_size

layers

heads

max_seq_len

top_k

top_p

sampling parameters...

And then there was tokenization.

And then the dataset.

And then training.

And then the hardware.

And then CUDA.

And then multi-GPU.

And then...

You get the idea. 😭

At some point I started thinking:

What if I could just give the system my data and let it figure most of this stuff out?

That thought eventually became Tensorless.

Before Tensorless

I wasn't starting completely from zero.

While learning PyTorch and experimenting with language models, I eventually built two models myself.

One was around 91M parameters.

Another was around 35M parameters.

That experience was actually what pushed me toward Tensorless.

Because once you build a model yourself, you start seeing just how many decisions are involved.

And I started wondering:

What if someone just wants to experiment with a small or medium-sized language model without having to become an expert in every single configuration option first?

That was the problem I wanted to solve.

My first approach was probably too ambitious 💀

The original Tensorless idea was much more extreme.

I wanted Tensorless to have its own neural-network components, its own processing, its own structure, and its own training system.

Basically, I was trying to build a lot of the stack myself.

It sounded cool.

It also caused a ridiculous number of problems.

GPU support had issues.

Multi-GPU had issues.

TPU setup had issues.

There were bugs I had to chase because I was trying to control things that frameworks like PyTorch already handle extremely well.

Eventually I realized:

I don't need to reinvent PyTorch to simplify model training.

So I changed the direction.

Tensorless-PyTorch

The current version uses PyTorch underneath.

Tensorless becomes the higher-level layer that tries to automate the annoying parts.

The package is available on PyPI:

Tensorless PyTorch on PyPI

Install it:

pip install tensorless-pytorch

Then:

import tensorless as tl

model = tl.train("./corpus.txt", task="text-generation")

print(model.generate("The", max_new_tokens=40))

That's an actual example from the package's current PyPI documentation.

And that's basically the philosophy of Tensorless:

Give it data. Train. Generate.

So what does Tensorless actually automate?

When you train a text-generation model, Tensorless can derive a number of settings from the data instead of making you configure everything manually.

The current package automatically derives things such as:

model size
batch size
epochs
validation setup
device
BPE vocabulary size

The model size is automatically scaled according to corpus size across several tiers.

And if you do want control, you can override the automatically selected settings.

So you can start simple:

model = tl.train(
    "./corpus.txt",
    task="text-generation"
)

Or start taking control of the configuration:

model = tl.train(
    "./corpus.txt",
    task="text-generation",
    epochs=20,
    max_seq_len=128
)

The idea isn't:

"You are never allowed to configure anything."

It's:

"You shouldn't have to configure everything just to get started."

Tokenization is handled too

For text training, Tensorless currently uses BPE as the default tokenizer.

You can also explicitly choose character-level tokenization:

model = tl.train(
    "./corpus.txt",
    task="text-generation",
    tokenizer="char"
)

The text is tokenized once up front and then streamed through PyTorch in fixed-size batches.

That means the user doesn't have to manually build an entire tokenization → batching → training pipeline before experimenting.

What about pretraining?

There is also a starter English pretraining workflow.

For example:

import tensorless as tl

model = tl.pretrain(
    out="english.tl",
    epochs=20,
    max_seq_len=128
)

print(
    model.generate(
        "A complete sentence",
        max_new_tokens=30
    )
)

Tensorless includes an offline starter corpus for demonstrations and smoke tests.

But it's important to say this clearly:

That starter corpus isn't supposed to magically produce a powerful LLM.

It's there to demonstrate the pipeline.

For actual pretraining, you should provide your own substantially larger corpus.

And you can fine-tune

This is one of the things I wanted to support beyond just:

"Here's a dataset, train from scratch."

You can train a base model:

base = tl.train(
    "./big_corpus.txt",
    task="text-generation",
    out="base.tl",
    epochs=20
)

Then fine-tune it:

tuned = tl.train(
    "./my_conversations.json",
    task="text-generation",
    out="tuned.tl",
    pretrained="base.tl",
    epochs=5
)

The current implementation keeps the architecture and tokenizer aligned with the pretrained model when using pretrained=, rather than silently accepting incompatible overrides.

That's useful because the whole point of fine-tuning is to build on what the base model already learned.

It isn't only text generation

Tensorless isn't limited to language models.

The current package also exposes other training tasks.

For example:

tl.train(
    "reviews/",
    task="text-classification"
)

And tabular regression:

tl.train(
    "housing.csv",
    task="regression"
)

The package also supports tabular classification, with preprocessing for things such as numeric values, ISO dates, and high-cardinality categories.

So the broader idea became:

Don't make every experiment start with a giant configuration file.

What about GPUs?

This was one of the reasons the original from-scratch version became difficult.

In the current PyTorch-based implementation, CUDA training can automatically use mixed precision where supported.

The current version also supports TPU training through:

device="tpu"

And larger automatically sized models can enable gradient checkpointing to reduce memory usage.

That's one of the big lessons I learned from the original Tensorless:

Sometimes the best engineering decision is not to rebuild something that already works.

Then I built a cat. 🐈

After building a framework for training models, I needed an actual project to play with it.

So obviously...

I made a chatbot that talks like a dramatic cat.

Introducing:

CatTongue on GitHub

CatTongue is a tiny Tensorless-powered chatbot trained on human messages and cat responses.

The repository is intentionally simple.

Its structure looks roughly like:

CatTongue/
├── data/
│   └── conversations.json
├── train.py
├── chat.py
├── README.md
└── .gitignore

The actual repository also contains trained .tl model files and the training/chat scripts.

Running CatTongue

First install Tensorless:

pip install tensorless-pytorch

Then train:

python train.py

That produces:

cat.tl

Then:

python chat.py

And you can talk to the cat.

That's the actual workflow documented in the CatTongue repository.

The dataset is ridiculously simple

The training data lives in:

data/conversations.json

An individual example looks like:

{
  "user": "what are you doing?",
  "cat": "mrrp... watching the wall. the wall is suspicious."
}

So if you want to experiment with the personality, you can literally add more conversations.

More data.

Different responses.

Different personality.

Then train again.

That's one of the things I like most about this experiment: the entire pipeline is accessible enough to mess with.

And yes, the model is imperfect 😂

Some of the CatTongue outputs are genuinely funny.

Others are completely broken.

And that's expected.

This isn't a massive pretrained language model.

It's a small experiment trained on a small dataset.

The repository even has examples where the model produces grammatically broken or nonsensical responses.

But that's actually useful.

Because you can see the relationship between:

data → training → model behavior.

Change the dataset and train again.

The behavior changes.

That's exactly the kind of experimentation I wanted Tensorless to make easier.

Why "Tensorless"?

The name came from the original idea.

I wanted the user to think less about the underlying tensor/model configuration and more about:

What data do I want to train on?

It's not literally "tensor-free."

PyTorch is underneath it.

The name is more about the abstraction.

You don't need to manually deal with every underlying detail before you can start experimenting.

A year later...

It's kind of funny looking back.

I started this because I was learning PyTorch and getting confused by all the configuration.

Then I tried building basically everything myself.

That caused problems.

Then I realized I could use PyTorch instead of fighting it.

And now Tensorless is an actual Python package.

The current PyPI release is 0.8.0, published on August 27, 2026, and the package is MIT licensed.

The project is still evolving.

There are things I want to improve.

There will definitely be bugs.

And there are probably design decisions I'll change later.

But that's what makes open source interesting.

So, what can you do with it?

You can start ridiculously simply:

import tensorless as tl

model = tl.train(
    "./my_data.txt",
    task="text-generation"
)

Or you can go deeper and configure the training yourself.

You can pretrain.

You can fine-tune.

You can do text classification.

You can work with tabular data.

You can save models as .tl.

You can load them later:

model = tl.load("model.tl")

print(model.info())

All of these are part of the current package API.

It's not trying to replace serious ML frameworks

Tensorless isn't meant to replace PyTorch.

Actually, it uses PyTorch.

That's intentional.

PyTorch already gives us an enormous amount of mature infrastructure.

Tensorless sits above it and tries to make certain workflows more automated.

Think of it as:

Your data
   ↓
Tensorless
   ↓
automatic configuration
   ↓
tokenization / preprocessing
   ↓
model + training setup
   ↓
PyTorch
   ↓
trained model

The goal is to reduce the amount of boilerplate between:

"I have some data"

and

"I have a model I can experiment with."

Where it goes from here

I don't know exactly.

That's part of the fun.

I want to keep improving the automation, hardware support, training behavior, documentation, and model capabilities.

And I want people to actually use it.

Break it.

Experiment with it.

Build weird projects with it.

Find bugs I didn't find.

Send pull requests.

Maybe someone will build something genuinely useful with it.

Maybe someone will build another ridiculous chatbot.

Both are fine. 😂

Try it yourself 🚀

PyPI:
tensorless-pytorch

CatTongue:
DeveloperPuneet/CatTongue

Install:

pip install tensorless-pytorch

Then try:

import tensorless as tl

model = tl.train(
    "./corpus.txt",
    task="text-generation"
)

print(
    model.generate(
        "The",
        max_new_tokens=40
    )
)

And if you want something more entertaining, clone CatTongue and train the dramatic cat. 🐈

One last thing

Tensorless started because I thought:

"Why are there so many things I have to configure just to train a model?"

A year later, I ended up publishing the answer I came up with.

It's not perfect.

It's not some revolutionary new architecture.

It's not going to train a frontier model on your laptop.

It's simply an attempt to make model training less annoying to start with.

And honestly?

I'm pretty happy that the idea that started with me being confused about PyTorch eventually became a package people can actually pip install.

Now I want to see what other people do with it. 🚀

I Was Learning PyTorch, Then I Accidentally Started Building My Own AI Training Framework

Puneet-Kumar2010 — Sun, 23 Aug 2026 10:48:35 +0000

Honestly, Tensorless was not supposed to become this big.

I was learning PyTorch.

I wanted to understand how neural networks and model training actually worked, so before starting Tensorless, I built two AI models with PyTorch.

Those two projects were mainly for learning. I wanted to understand the basics by actually building things instead of only reading tutorials.

And after doing that, I started thinking about something pretty simple:

Why does training a model have to involve so much setup every time?

If I already have the training data, why can't I just give it to a framework and let it figure out most of the boring stuff?

That was the beginning of Tensorless.

First, I Built Two Models With PyTorch

Before Tensorless existed, I spent time learning PyTorch by actually building two AI models.

That gave me a basic understanding of how the whole process worked:

Preparing data
Creating a model
Training
Loss
Optimizers
Batching
Saving models
Loading models
Inference
And all the configuration around training

Building those two models was important because I wasn't starting Tensorless completely blind.

I had already experienced the process myself.

And after doing it twice, I started noticing how much of the setup was repetitive.

Sometimes I don't want to spend a huge amount of time configuring everything.

Sometimes I just want to get a result quickly.

So I started thinking:

What if most of this could just happen automatically?

The Original Idea Was Actually Pretty Simple

My initial goal wasn't to create another huge machine-learning framework.

I wanted something more like:

Give Tensorless your training data
↓
Tensorless figures out the setup
↓
Train
↓
Get your model

The idea was basically:

Put data in → go.

If you're a beginner, you shouldn't need to understand every training parameter before you can train a model.

But if you're an advanced programmer, you should still be able to configure everything yourself.

So the philosophy became:

Simple by default. Configurable when you need it.

The First Tensorless Version Used PyTorch

The first version of Tensorless actually used PyTorch underneath.

I wasn't trying to reinvent neural networks at that point.

I was trying to automate the training process.

The configuration was mostly determined automatically using fixed conditions in the code.

So instead of manually deciding every parameter, Tensorless would make those decisions for you.

That was the first version.

And honestly, it worked surprisingly well for what I wanted.

But then I ran into another problem.

I Wanted It To Be Small

One of the reasons I started thinking differently about the architecture was the amount of stuff involved in a PyTorch-based workflow.

When I was experimenting with the project, the dependencies and modules could become 500+ MB.

And I started thinking:

"I'm trying to make training simpler and lightweight, but I'm bringing in a huge stack just to do it."

I didn't want Tensorless to become a massive package full of components that users might never need.

I wanted the package to contain the things actually required for its own workflow.

So I decided to go much further.

Then I Made A Slightly Insane Decision

I started building more of the system myself.

Instead of keeping Tensorless as a PyTorch wrapper forever, I started working toward my own neural/training system.

That meant getting into things I originally hadn't planned to touch.

I started working on:

Neural network components
Training
CUDA optimization
Data optimization
Data pipelines
TPU support
Automatic configuration
Tokenization
BPE
Model saving/loading
And other training infrastructure

At this point, Tensorless had changed completely.

It wasn't just:

"PyTorch, but with easier configuration."

It was becoming an attempt to build a lightweight training system around the workflow I wanted.

Then I Needed Something Real To Test It On

So I built a small chatbot.

A cat chatbot.

I called it CatTongue. 🐈

The model was trained on CPU, and with the PyTorch-based version of my training system, I was getting results that were honestly pretty fun.

For example:

You: "Do you trust me?"
Cat: "only if you walk toward the kitchen. 😼🐾"

You: "Who is your enemy?"
Cat: "empty boxes. 📦😾 they are useful for exactly zero seconds."

You: "Who is your favorite human?"
Cat: "are you holding food? 🤨🍗"

You: "Do you have a best friend?"
Cat: "the vacuum cleaner. 😾🧹 we have unfinished business."

It wasn't perfect.

But it was understandable.

The model was actually producing responses that made sense.

And I thought:

Okay. This is working.

Then I Changed The Training System Again

I continued developing my own training implementation.

And then I trained again.

This time...

OH MY GOD.

The results were terrible. 😭

I started getting things like:

You: Hello
Cat: yes. � I understand the ancient languagnacke.

You: do you want food?
Cat: food. �� I have interrupt the sound forctinking.

You: fish?
Cat: food. � � � suspicious.

You: who is your enemy?
Cat: yes. � I amain but jobs.

You: meow
Cat: okay. � I superiore your fish.

You: kitchen
Cat: fish. � They are you mrrp.

And my reaction was basically:

FAAAAAAAAAAAAAAAAAAAAH.

😂

There were recognizable words.

There were sometimes recognizable meanings.

But the language wasn't behaving properly.

And this was actually one of the most important moments in the project.

Running a Neural Network Isn't The Same As Making It Learn Properly

I had already learned how to make the system train.

I had a model.

I had data.

I had a training loop.

I had the infrastructure.

But getting something to actually learn useful language representations is a completely different problem.

That experiment showed me that my implementation still had a lot to improve.

And that's where I started understanding the difference between:

"The code runs."

and

"The model works well."

Those are VERY different things.

But The API Was Becoming What I Wanted

Even while the underlying system still needed work, the interface was becoming extremely simple.

For example, pretraining and fine-tuning can look like:

import tensorless as tl

print("Pretraining base model...")

base_model = tl.pretrain(
out="pretrained_base.tl",
max_seq_len=30
)

print("Base model pretrained -> pretrained_base.tl")

print("Fine-tuning on cat conversations...")

model = tl.train(
"data/conversations.json",
pretrained="pretrained_base.tl",
out="cat.tl",
)

print("CatTongue trained successfully!")

That's basically the experience I'm trying to create.

You don't need to write a massive training script.

You don't need thousands of lines just to get started.

You provide your data.

Tensorless handles the setup.

And if you want to customize things, you can.

Beginner vs Advanced User

This is something I really want Tensorless to get right.

If you're a beginner

You shouldn't have to understand every parameter.

You should be able to do something like:

model = tl.train("data/")

and get started.

If you're an advanced programmer

You should be able to configure the training yourself.

I want all the important configuration to be accessible in one place rather than making someone jump through a huge project just to change one setting.

So the idea is:

One simple function for beginners. Deep configuration for advanced users.

I Also Wanted It To Stay Lightweight

Another thing I'm trying to maintain is the overall package size.

Tensorless is currently under roughly 30–40 MB overall, rather than pulling in a huge collection of unnecessary components.

That's important to me because the original reason for this project was partly:

I want to experiment without needing a giant stack just to get started.

I don't want someone to install Tensorless for a small experiment and feel like they installed an entire operating system. 😭

Tensorless Is Now Actually Open Source

The project is available on GitHub and PyPI.

GitHub: https://github.com/DeveloperPuneet/Tensorless
PyPI: https://pypi.org/project/tensorless/

And CatTongue is also open source:

CatTongue: https://github.com/DeveloperPuneet/CatTongue

The CatTongue experiment is one of the things I'm using to test whether the training system is actually improving.

And Now I'm Stuck On The Hard Stuff

This is where the project is today.

The basic system works.

The API works.

Training works to a certain extent.

The automatic setup works.

But now I'm running into problems that aren't as easy as writing another Python function.

CUDA

I've been working on CUDA support and optimization.

The system can detect the GPU and show GPU-related activity, but I'm having problems getting the actual training workload to behave properly on the GPU.

Basically:

The GPU is detected, but it doesn't always mean the training is actually being accelerated the way it should be.

That's something I really want to fix.

TPU

I've also started working toward TPU support.

Again, detection is one thing.

Actually getting the training workload to execute correctly on the TPU is another.

So TPU support is currently something I want to improve substantially.

Multi-GPU

I've also been working on multi-GPU support.

The problem is that detecting multiple GPUs doesn't automatically mean the training workload is correctly distributed across them.

I want multi-GPU training to actually make use of the available devices rather than simply detecting them.

Training Results

This is probably the biggest issue.

The same training data can behave differently depending on the implementation.

My current training implementation doesn't always produce results comparable to established training frameworks.

The CatTongue experiment made that very obvious.

The model can learn words.

It can sometimes learn relationships between words.

But getting consistently good results is another level.

Automatic Configuration

The automatic configuration is also something I want to improve.

Right now, some decisions are based on predefined logic.

That's useful, but it isn't flexible enough for every dataset or model.

I want the system to become smarter about determining what configuration makes sense.

This Is Where I Need Help

And honestly, this is the main reason I'm writing this article.

I'm still learning.

I started this entire project because I was learning PyTorch.

I built two models with PyTorch.

Then I started automating the process.

Then I started building my own system.

And now I've reached areas where there are people who know way more than I do.

If you have experience with:

CUDA
GPU optimization
TPU/XLA
multi-GPU training
neural network implementation
training stability
data pipelines
model optimization
BPE/tokenization
machine-learning infrastructure

I'd genuinely love feedback.

You don't have to write code.

Even finding a problem and explaining why something is wrong would help.

And if you want to contribute code, even better.

The project is open source and the issues are there for exactly this reason.

What I Want To Build Next

I have a pretty ambitious list of things I'd like to experiment with.

Some of the ideas currently on my roadmap are:

Better CUDA optimization
Proper TPU training
Reliable multi-GPU training
Smarter automatic configuration
Improved data pipelines
More training/data formats
Additional model architectures
Game integration
CLI-based AI interaction
UI-based AI interaction
User-vs-AI experiences
Reinforcement learning
Q-learning
Deep Q-learning
And more

The goal isn't necessarily to implement everything immediately.

I want to keep expanding the system as I learn.

From Two PyTorch Models To Tensorless

Looking back, the progression is kind of funny.

I started with:

"I want to learn PyTorch."

Then I built two models with PyTorch.

Then:

"Why do I have to configure all this stuff every time?"

So I started automating it.

Then:

"Why is this getting so heavy?"

So I started trying to make it lightweight.

Then:

"What if I build more of the system myself?"

Then came:

CUDA.

TPUs.

Data pipelines.

BPE.

Multi-GPU.

And then eventually:

"Why does my cat suddenly speak ancient alien language?" 💀

That's basically how Tensorless happened.

I didn't start this project because I thought I could build something better than PyTorch.

I started it because I wanted to make one specific thing easier:

Take training data → configure as little as possible → train a model.

I wanted something where beginners could just give it their data and go, while advanced users could still control the system when they needed to.

And now I'm trying to figure out how far I can actually take that idea.

If You Want To Check It Out
Tensorless

https://github.com/DeveloperPuneet/Tensorless

https://pypi.org/project/tensorless/

CatTongue

https://github.com/DeveloperPuneet/CatTongue

If you're interested in the project, try it, break it, report something, suggest something, or contribute.

Especially if you understand the parts I'm currently struggling with.

I'm still learning.

That's kind of the whole reason this project exists.

I started by learning PyTorch.

Now I'm learning what it actually takes to build the stuff underneath it.

And honestly?

I'm curious to see where this goes. 🚀

People Liked My Product. They Just Didn't Need It.

Puneet-Kumar2010 — Mon, 17 Aug 2026 03:37:39 +0000

I recently learned something about building products that I probably should have understood much earlier:

People liking your product doesn't necessarily mean they need it.

I built a platform called Rizzzler, an open-source profile/link-in-bio platform.

The idea was pretty simple.

I'd seen people using platforms where they could put a link in their social media bio and create a small personal page. I thought I could build my own version — something simple, fast, customizable, and a little more fun.

So I built it.

And because I wanted people to be able to trust what they were using, I made the project open source too.

I spent a lot of time building the actual product.

There are profiles, customization, coins, notifications, milestones, community chat, and other small systems intended to make the platform feel less like a static link page and more like something people could actually interact with.

At that point, I thought:

"Okay, now I just need people to find it."

That turned out to be the easy part.

Then I started promoting it.

I submitted Rizzzler to places like Product Hunt, SaaSFrame, and other platforms where people discover new products.

And for a few days, things actually looked pretty good.

I started getting visitors.

At one point, the traffic was above the 25th percentile for the category I was looking at in GA4.

People were visiting.

Some people signed up.

And I started getting feedback like:

"Good UI."

"This is good."

"Someone finally made link-in-bio profiles look cool."

Those comments felt great.

They also gave me a slightly dangerous impression:

Maybe I've built something people actually want.

Then the traffic stopped.

Not gradually.

It just became cold again.

The initial spike from launching and posting about the product disappeared, and there wasn't enough organic interest to keep bringing people back.

That was the part I didn't expect.

The product wasn't necessarily bad.

This is something I've been thinking about a lot.

I don't think the main problem was that Rizzzler was completely useless.

People could understand what it did.

People could use it.

Some people even liked the design.

But when I actually talked to people about creating an account, I started hearing a different kind of feedback.

Something along the lines of:

"The product is good, but I don't really need this."

And honestly, that sentence taught me more than the positive reviews did.

Because a positive review tells you:

"This is nice."

But a person refusing to use your product tells you:

"This doesn't solve a problem important enough for me to change my behavior."

Those are very different things.

I underestimated marketing.

When I started building, I mostly thought about the product itself.

How should the UI look?

What features should I add?

How can I make it faster?

How can I make people interact with it?

So I kept adding things.

Coins.

Community chat.

Milestones.

Notifications.

Small features intended to encourage people to return.

But there was a problem underneath all of that:

I was trying to improve retention before I had really proven that people wanted to return.

That's a mistake I understand much better now.

You can't solve a demand problem by endlessly adding features.

And you can't necessarily advertise your way out of a demand problem either.

The interesting part about advertising

This made me question something I've been thinking about:

Is advertising a product actually worth it if people don't already have a reason to use it?

You can put your product in front of people.

You can post it on Product Hunt.

You can submit it to directories.

You can write posts.

You can share it on social media.

You can get hundreds or thousands of impressions.

But if someone sees it and thinks:

"That's cool, but I don't need it."

then the traffic doesn't really mean much.

You may get visitors.

You may get likes.

You may even get compliments.

But once the promotion stops, everything goes quiet again.

That's basically what happened to me.

The traffic came when I told people about Rizzzler.

Then the traffic went away when I stopped telling people.

That was a pretty useful reality check.

And some users did join.

This is another part I don't want to ignore.

Rizzzler wasn't completely empty.

Some people signed up.

Some visited more than once.

But most weren't coming back regularly.

And that made me look at another assumption I'd made.

I had built things like newsletters, milestones, coins, community chat, and other mechanisms to encourage interaction.

But those things don't automatically create a reason for someone to return.

If the underlying product isn't something they genuinely need, a notification or reward system isn't going to magically turn it into a habit.

Retention starts with value.

Not with notifications.

So what did I actually learn?

Probably more than I expected from one small project.

Building isn't the same as validating.

I spent a lot of time making the product better before fully understanding whether the problem was important enough to solve.

Next time, I want to validate the need much earlier.

"People like it" isn't enough.

A person saying your product is cool is nice.

A person changing their behavior because they need your product is much more meaningful.

Marketing isn't just posting links.

I used to think of marketing mostly as getting the product in front of people.

Now I think it's much more about understanding:

Who actually needs this? Why do they need it? And why would they choose this instead of doing nothing?

Traffic can be misleading.

A launch can create a nice graph.

But a spike isn't the same thing as sustainable growth.

The more interesting number is what happens after everyone stops talking about you.

Features can't manufacture demand.

You can build a coin system.

You can build a community.

You can build notifications.

You can build a beautiful dashboard.

But none of those things matter much if the user doesn't have a strong reason to come back.

Open source doesn't automatically create users either.

I made Rizzzler open source partly because I wanted people to be able to inspect and trust the project.

I'm still happy that I did it.

But open source is not a substitute for distribution, product-market fit, or understanding your audience.

It's one part of the product story — not the whole story.

But I'm not calling Rizzzler a failure.

Actually, I don't think of it that way.

If anything, it gave me something I couldn't have learned by just watching videos about startups.

I experienced the entire cycle myself:

Build → Launch → Get attention → Get feedback → Watch the attention disappear → Figure out why.

And that experience is valuable.

I also learned that I genuinely enjoy building things.

Even after seeing the traffic disappear, my first thought wasn't:

"I'm never building again."

It was:

"Okay... what should I build next?"

That's probably the most important thing I got from this.

So, what's next?

I'm thinking about building something else.

Maybe it will make money.

Maybe it won't.

Most of the things I've built so far have been free anyway.

But this time, I want to start with the problem before the product.

I want to talk to people first.

I want to understand what annoys them, what they already use, what they refuse to use, and what problem is actually painful enough for them to care about.

Then I'll build.

Maybe the next thing will work.

Maybe I'll make another mistake.

Either way, I think that's part of the process.

I don't necessarily want to build something just because it can make money.

I'd like to build something that I created, that other people genuinely find useful, and that contributes something to the world — even if it's small.

And I'll try to keep improving it, keeping it useful, and updating it as quickly as I can.

That's probably a better goal than simply watching a traffic graph go up.

If you're building something too: what was the biggest lesson you learned from your first product?

And if you have an idea for something worth building, I'd genuinely love to hear it. Maybe we could even build something together.