DEV Community: Muhamad Revanza Rafif Hamdani

I Made 39 Digital Products and Sold Almost Nothing. The Product Was Never the Problem.

Muhamad Revanza Rafif Hamdani — Thu, 01 Oct 2026 13:03:38 +0000

I still remember refreshing the dashboard at 2am, hoping the number would change.

It did not. Thirty-nine products in the store, a clean landing page, decent covers, and almost no sales. I had done the thing every guide tells you to do. Make a good product. Make more of them. Ship.

The problem was that I had optimised the wrong half of the business.

The trap of building

Building feels like progress. You can see it. You generate the files, you write the description, you hit publish, and something new exists in the world that did not exist an hour ago. It is deeply satisfying, and that satisfaction hides a very simple fact.

A product nobody can find is a product nobody can buy.

I had confused having something to sell with having a business. Those are different problems. The first one I could solve alone, at night, with code. The second one required something I had not built at all: a way for strangers to arrive.

The number that changed how I think

When I dug into how people actually reach a store like mine, one statistic stopped me cold. On Gumroad, roughly 40% of visits are people typing the URL directly. They already knew the creator. They came on purpose.

That is the whole game. Discover pages, search, and social all amplify a store that already has an audience. They do not create one from nothing. The platform is a cash register, not a traffic engine. It will happily take money from people who already decided to buy. It will not introduce you to them.

The second number was worse. Around 44% of products on the platform earn zero. Not a little. Zero. And it is almost never because the product is bad. It is because nobody ever saw it.

What I did instead

So I stopped building and started distributing. I made a simple rule: every product needs a page that can be found by someone who has never heard of me.

That meant writing pages around the exact words a real buyer types. Not "sticker pack". Something like "cute dinosaur stickers PNG for Cricut". Long, specific, low-competition, and written for a person who is already looking to solve a small problem.

I built 76 of those pages on a host Google can index, plus 42 more on an anonymous paste site that also gets crawled. Every page points back to a free sampler. The sampler points to the paid packs. That is the funnel, and it only works because each entry point answers a real search.

It is not glamorous. Writing 118 pages is not fun the way shipping a product is fun. But it is the half of the business that was missing.

The uncomfortable lesson

If your product is not selling, the default assumption is that the product is not good enough. Sometimes that is true. More often, the product is fine and invisible.

Before you build product number forty, count how many doors you have built that lead to product number one. If the answer is zero, you already know what the next month is for.

If you are building something similar and want to see what the output looks like, I keep a free pack of cute kawaii stickers (transparent PNG, commercial use) here, no email needed:

Free cute sticker sampler

The full catalogue is browsable at revanzart.gumroad.com.

How I Run a Full Content Pipeline on a $7 VPS With 2GB of RAM (And the 3am Crash That Taught Me Why)

Muhamad Revanza Rafif Hamdani — Thu, 01 Oct 2026 05:50:56 +0000

The cron job ran at 3am and the server went dark.

I woke up to a dead SSH session, a swap file that had been chewed through, and a pipeline that had produced nothing. The task was simple on paper: generate a batch of images, vectorise them, package them, upload them. On my laptop it took a few minutes. On a 1 vCPU box with 2GB of RAM it killed the machine.

I had written code that worked. I had not written code that fit.

Why small servers die

The mistake was concurrency. I processed everything at once, because that is the default when you write a loop. Ten images in flight means ten copies of the model, ten decoded bitmaps, ten sets of intermediate buffers. On a big machine that is a rounding error. On 2GB it is the entire budget, and the kernel reaches for swap, and swap on a cheap VPS is a slow death.

The fix was not a bigger server. It was a smaller pipeline.

The rules I now follow

One process at a time. The pipeline runs a single job, finishes it, frees the memory, and starts the next. It is slower in wall-clock terms and dramatically more reliable. For a background job nobody is watching, reliability is the only metric that matters.

Measure peak, not average. Average memory usage lies. A step that idles at 40MB and spikes to 900MB for two seconds will still kill you. I now log peak RSS per step, so I know exactly which stage is the dangerous one before it runs at 3am.

Cap the inputs. Most pipelines do not need to load a full-resolution source to produce a small output. I resize before the expensive step, not after. The model sees what it needs and nothing more.

Garbage collect on purpose. In Python, the reference counting is not always fast enough for big binary objects. Calling gc.collect() between heavy steps costs milliseconds and gives back hundreds of megabytes.

What the numbers looked like

After the rewrite, generating a full batch of images peaked at 29MB of RSS. Twenty-nine. The crash was never about the work being too big. It was about doing too much of it at the same time.

That batch now runs unattended. It has run dozens of times without me touching it, on the same cheap box, because it respects the ceiling it is running under.

The broader point

There is a temptation to treat infrastructure as someone else's problem, to assume that if the code is correct the server will cope. The server does not care about correctness. It cares about memory, and it will tell you exactly where your assumptions were wrong, usually at the worst possible hour.

If you are building automation on cheap hardware, budget memory the way you budget money. Know your peak. Do one thing at a time. Resize early. Free explicitly.

The whole system I run, generation, vectorising, packaging, and publishing, fits comfortably inside a tier that costs less than a coffee a week. Not because it is clever, but because it is disciplined about what it holds in memory at once.

If you want to see what the pipeline produces, there is a free set of kawaii stickers (transparent PNG, commercial use) here:

Free cute sticker sampler

The Long-Tail SEO Playbook for Digital Products (118 Pages, One Pattern)

Muhamad Revanza Rafif Hamdani — Wed, 30 Sep 2026 18:03:48 +0000

The first page I wrote got zero traffic. So did the second.

The tenth page got a little. By the time I had written a hundred, the pattern was obvious, and it had nothing to do with writing better. It had to do with writing narrower.

Why broad keywords lose

If you sell stickers and you write a page titled "Stickers", you are competing with the entire internet for a word that means everything and nothing. You will lose, and even if you won, the traffic would be useless because the person searching "stickers" has no idea what they want yet.

Buyers do not search in categories. They search in problems. "Cute dinosaur stickers PNG for Cricut" is not a prettier version of "stickers". It is a completely different request. The person typing it has already decided what they want, which format they want it in, and what tool they are going to use it with. That specificity is the entire opportunity.

The pattern

Every page follows the same skeleton:

One intent per page. One product idea, one format, one use case. If a page is trying to catch two searches, it catches neither.

The keyword lives in the title, the first line, and the URL. Not stuffed. Placed where a search engine and a human both expect to find it.

The first paragraph answers the query immediately. If the search was "cute dinosaur stickers PNG for Cricut", the page opens by saying, plainly, that this is a set of cute dinosaur stickers in PNG format that works in Cricut. Answer-first writing is also what gets pulled into AI search results, which now sit above the classic blue links.

A clear next step. Not a wall of ads. One honest pointer to the relevant product, and one to a free sample.

Why volume matters here

Long-tail pages are small. Each one catches a trickle. The trickle only becomes a stream when there are many of them, each targeting a slightly different buyer. 118 narrow pages beat one broad page, not because any single page is impressive, but because together they cover a hundred different ways a person might describe the same small need.

The cost is time. Writing them is repetitive, and the results are slow, often 60 to 90 days before search engines trust the content enough to rank it. That is the tax. The upside is that once a page ranks, it keeps working while you sleep, which is the opposite of social media, where a post is dead in a day.

The honest caveat

This is not a growth hack and it does not replace having something worth finding. If the product is bad, a hundred pages will just route a hundred times more people to a disappointment. The pages are a multiplier. The product is the thing being multiplied.

If you want a fast way to see the quality of what I make, there is a free sampler of cute kawaii stickers (transparent PNG, commercial use) here:

Free cute sticker sampler

The full set of themes is at revanzart.gumroad.com.

Nobody Warns You About the Boring Parts of Selling Digital Products

Muhamad Revanza Rafif Hamdani — Wed, 30 Sep 2026 18:03:07 +0000

Nobody makes a video about the boring parts.

The videos are about the idea, the launch, the first sale, the graph that goes up and to the right. What they leave out is the month of writing product descriptions, resizing covers, tagging keywords, and answering the same support email four times. That part does not trend, and it is the part that decides whether any of it works.

The work that does not feel like progress

When I started, I assumed the creative work was the job. Design the thing, ship the thing, done. What I found instead was that the creative work is maybe a fifth of it. The rest is plumbing.

Writing a description that a real person can read without wincing. Making sure the file opens in the tool the buyer actually uses. Setting the licence so a print-on-demand seller is not exposed. Naming the file something a human can find in a folder of forty downloads. None of it is clever. All of it is the difference between a purchase and a refund.

Why people quit here

The boring parts arrive right after the exciting part ends. You have shipped. You feel good. Then you look at the list of small, unglamorous tasks between you and a sale, and it is long and grey. Most people stop there and start a new product instead, because a new product feels like progress again.

That is the loop. A shelf of half-finished things, each abandoned exactly where the boring work began.

The fix is automation, applied to the boring parts specifically

The insight that saved me was simple: the boring parts are boring because they are repetitive, and repetitive work is exactly what a script is for. So I automated them, one at a time.

Generating the cover. Writing the description from a template plus real details. Setting the category and keywords. Uploading, publishing, and remembering what had already been done so nothing gets posted twice. Each piece is small. Together they removed almost all of the grey work and left me the creative part, which is the part I actually enjoy.

The rule I follow now: if I do a task three times by hand, it becomes a script the fourth time. Not because I love automation, but because manual repetition is the thing that makes me quit.

The real lesson

Selling digital products is not a creativity problem. It is a consistency problem. The winners are rarely the most talented. They are the ones who did not walk away when the work stopped being fun, and who built systems so that the un-fun work took care of itself.

Find the boring part. Automate it. Then do it again, forever, and let it compound.

If you want to see the result of that compounding, there is a free pack of cute kawaii stickers (transparent PNG, commercial use) here, no email required:

Free cute sticker sampler

From One Prompt to a Product Catalogue: How I Turned a Single Idea Into a Repeatable System

Muhamad Revanza Rafif Hamdani — Wed, 30 Sep 2026 18:02:32 +0000

The first sticker pack I made was luck. I had an idea, I spent an evening on it, and it happened to be good.

The second one was not luck. It was me trying to remember how I did the first one, and failing. Different canvas size. Different line weight. A colour palette that did not match. The two packs looked like they were made by two different people.

That is when I stopped thinking about the product and started thinking about the system.

One idea is a lottery ticket

An idea that works once is fragile. You cannot rely on it, you cannot scale it, and you cannot hand it to anyone. You got lucky, and luck does not repeat on command.

A system is different. A system takes an input, applies a fixed set of rules, and produces an output you can predict. The output is only as good as the rules, but the rules can be improved, and once they are good, they keep being good for every future input.

What the system actually is

Mine has five stages, and the important thing is that each stage is fixed before the next one runs.

A locked spec. Before generating anything, the rules are set: consistent line weight, a fixed canvas size, a defined palette, transparent backgrounds, a hard cap on file size. Every product that comes out of the pipeline inherits these. That is why the whole catalogue looks like one brand instead of a junk drawer.

Generation. The spec goes in, a raw sheet comes out. Consistent, but not yet sellable.

Vectorising. This is the stage most people skip. A PNG is a picture. An SVG is a file you can cut, resize, and recolour forever, and it is what professional buyers and cutting-machine users actually need. Running every sheet through a tracer is the single step that separates a hobby pack from a professional one.

Packaging. Every product ships the same way: individual transparent PNGs, a sticker sheet, an EPS, an SVG, a preview, and a plain-language commercial licence. The buyer knows exactly what they get because every product is built the same.

Publishing. The upload, the description, the cover, the keywords, and the category are all generated by script. The only thing left for a human is the decision of what to make next.

Why this matters more than any single product

A catalogue built by a system compounds. Each new product inherits the quality of the ones before it, the brand stays consistent, and the marginal cost of the next product drops toward zero. A catalogue built by hand resets every time, which means every product is a fresh gamble.

The system is the asset. The products are just what it produces this week.

If you want to see what a system-built catalogue looks like, there is a free pack of cute kawaii stickers (transparent PNG, commercial use) here:

Free cute sticker sampler

The full range is browsable at revanzart.gumroad.com.

I Built an AI Pipeline That Turns One Idea Into 39 Sticker Packs (Here's the Whole System)

Muhamad Revanza Rafif Hamdani — Wed, 30 Sep 2026 17:58:12 +0000

I Built an AI Pipeline That Turns One Idea Into 39 Sticker Packs (Here's the Whole System)

How I went from one prompt to 39 commercially-licensed sticker sets, a Gumroad store,
and 118 indexable pages — without a GPU, on a $7/month VPS.

Last month I had a problem most creators will recognise: I could design one good sticker
pack, but scaling to a full catalogue meant weeks of manual work I didn't have time for.

So I did the boring, engineer-brained thing. I stopped designing stickers and started designing
a pipeline.

Today that pipeline has produced 39 sticker themes and 118 pieces of
indexable content. Everything runs on a single 1-vCPU VPS with no GPU. Here's exactly how it
works, including the parts that went wrong.

The stack (nothing exotic)

A tiny Linux VPS (1 vCPU, 2 GB RAM — the cheap tier)
Python for orchestration
A text-to-image model for the raw art
A vector tracer to convert raster art into clean EPS/SVG
The Gumroad API for the storefront

No fine-tuning. No custom model. No GPU. The whole thing costs less than a coffee per week to run.

Step 1: Generate, but with a strict spec

The temptation is to prompt "cute stickers" and hope. That produces garbage you can't sell.

Instead I locked the spec before generating anything:

One consistent art style across every icon (same line weight, same palette)
Fixed canvas sizes so every file is print-ready
Transparent backgrounds, always
A hard cap on file size so nothing gets rejected on upload

The output is a raster sheet: six icons on one transparent canvas. Consistent, but not yet sellable.

Step 2: Vectorise (this is the part people skip)

Marketplaces and Cricut users want vectors. A PNG is a picture; an SVG is a file you can cut,
resize and recolour forever.

I run every sheet through a vector tracer, which converts the raster art into paths. The result is
a real EPS + SVG that opens cleanly in Illustrator, Inkscape, Cricut Design Space and Silhouette
Studio.

This one step is the difference between "another PNG pack" and "a professional vector pack".
Buyers notice.

Step 3: Package it so it's usable in 30 seconds

Here's a rule I stole from software: the first 30 seconds decide whether someone uses your product.

So every pack ships as:

Individual transparent PNGs (drag straight into GoodNotes)
A single PNG sticker sheet
An EPS vector (Illustrator 10 compatible)
An SVG (Cricut / Silhouette)
A preview image
A plain-language commercial-use license

No zip full of mystery files. No README that assumes you're a designer.

Step 4: Automate the boring 90%

Uploading, writing descriptions, generating covers, setting categories — this is where creators
burn out. All of it is API calls.

I wrote a small uploader that uploads the file, sets a clean permalink, generates a cover and
thumbnail, writes an SEO-aware description, and publishes the product.

Then I hit one wall that surprised me: Gumroad only lets you create 10 new products per day.
Not a bug — a deliberate anti-spam limit.

The fix was a scheduled script that uploads 10 per day, remembers what it has already done (so it
never double-posts) and goes quiet when there's nothing left to do. Zero babysitting.

Step 5: The traffic problem (the real one)

Here's the uncomfortable truth: Gumroad is a cash register, not a traffic engine. You can have
the best product on the platform and sell nothing if nobody finds you.

So I built a free, automated distribution layer:

76 SEO pages on a Google-indexable free host, each targeting a long-tail buyer keyword ("cute dinosaur stickers PNG for Cricut")
42 promo pages on an anonymous, indexable paste site
Nostr posts to an open, account-free social protocol
A hub page that internally links the whole catalogue together

Every page points back to a free sampler, which points to the paid packs. That's the funnel:
attention → trust → sale.

What actually went wrong

I'll save you the pain:

Empty covers killed conversions. Every product launched without a cover image. Covers are the single biggest conversion factor on a marketplace. Fixed by automating cover generation.
The API lies by omission. The product list endpoint hides files and covers, so it looked like nothing was attached. The detail endpoint showed everything was fine. Never trust a summary.
Free ≠ free to sell. Plenty of "free" clipart is personal-use only. If you sell print-on-demand goods with it, you're exposed. Everything in my packs is explicitly commercial-use licensed.
Scaling breaks cheap servers. Running the whole pipeline at once on 2 GB of RAM is how you get a crash at 3am. I now measure peak memory per step and cap concurrency to one process.

The takeaway

The creators winning in 2026 aren't the ones with the best single product. They're the ones who built
a repeatable system — generate, vectorise, package, publish, distribute — and let it run.

You don't need a GPU, a team or a big budget. You need a spec, a pipeline and patience with the boring
parts.

Want to see the output? I put a free pack of cute kawaii stickers (transparent PNG, commercial-use)
here — no email required: Free cute sticker sampler

If you want the full collection, the mega bundle has every theme in EPS + SVG + PNG:
Cute sticker mega bundle

And if you're building something similar, the whole catalogue is browsable here: https://revanzart.gumroad.com