In Part 1, you chose a skill, picked a product format, and hopefully started testing your idea.
Now it’s time for a step that many first-time creators skip.
They come up with an idea and immediately start creating: recording lessons, designing presets, or building pages in Notion.
Then, somewhere along the way, the product becomes three times bigger than they originally planned.
That’s why, before creating anything, you need to decide what actually belongs inside the product.
The goal isn’t to create as much content as possible.
The goal is to create exactly what the customer needs to achieve the result you promised.
The Principle That Keeps Your Product From Growing Forever
One of the most common reasons a first digital product never gets finished is surprisingly simple.
The creator plans the product around everything they know, instead of around what the customer actually needs to achieve the result.
It might seem like a small distinction, but it makes a big difference.
When you plan around your own knowledge, the list of topics can grow forever.
There’s always:
“One more thing the customer should know…”
Then another.
And another.
Before long, a simple product can turn into a six-month project.
Instead, start with the destination.
Ask yourself:
“What does the customer need to know or be able to do to achieve the result I’m promising?”
Once the customer can achieve that result, the product is big enough.
That’s a good place to stop.
Example 1: A Mini-Course
Courses are especially easy to overcomplicate.
It can feel like more lessons automatically mean more value. But that’s not necessarily true.
For a first mini-course, you can use this as a practical starting framework:
3–7 modules — enough to create a clear learning path without making the course feel overwhelming;
2–4 lessons per module — if one module keeps growing, it may be covering too broad a topic;
5–15 minutes per lesson — shorter lessons are often easier to follow and complete;
one main idea per lesson — if a lesson tries to explain several different things, consider splitting it.
These are not strict rules. A good course can be shorter or longer.
The point is to give you a reasonable starting point instead of an endless list of topics.
For example, one mini-course might have five modules and around 15–20 short lessons. Another might need only three modules.
The right size depends on the result you’re promising.
Start With the Result, Not the Lesson Titles
For each module, ask yourself:
“What should the customer understand or be able to do after completing this module?”
Then break that result into smaller steps.
Each meaningful step can become a lesson.
For example:
Module: Build Your First Landing Page
Instead of:
What is Figma?
What is a frame?
What is a component?
What are colors?
What are fonts?
You could structure the learning process around the actual journey:
Set up your first Figma file
Build the page structure
Add typography and colors
Create reusable elements
Prepare the page for handoff or publishing
The second approach works better because every lesson moves the customer toward a specific result.
Give the Customer a Small Action After Each Lesson
Another simple thing that can make a difference: don’t make every lesson purely passive.
After a lesson, give the customer something small to do:
complete a short exercise;
change something in their own project;
answer a question;
create the next part of their product;
check their result against a checklist.
The goal isn’t to give homework for the sake of homework.
It’s to help the customer apply what they just learned.
Example 2: A Lightroom Preset Pack
Presets work differently from courses.
There are no modules or lessons. The product itself is the collection of presets.
So the main question becomes:
“What exactly does the customer need this preset pack for?”
Start with one clear theme instead of trying to cover every possible photography style.
For example:
Warm Tones for Wedding Photography
is much clearer than:
50 Ultimate Presets for Every Type of Photography.
Keep the Collection Focused
For a first product, 10–15 well-designed presets around one clear theme can be a better starting point than 40–50 loosely connected presets.
A larger number doesn’t automatically mean more value.
If half of the presets look almost identical or only work in very specific situations, the customer may actually find the larger pack harder to use.
Focus on usefulness and consistency, not the number of presets.
Test Every Preset
Don’t judge a preset by how good it looks on one carefully selected photo.
Test it with different:
lighting conditions;
skin tones;
locations;
compositions;
exposure levels.
A preset that looks great on one photo but produces poor results on another can quickly become a source of frustration.
Your goal isn’t to make every photo look identical.
Your goal is to give the customer a reliable starting point that they can adjust to their own images.
Think About How Customers Will Use It
If you’re selling Lightroom presets, consider which versions of Lightroom your audience actually uses.
If your target audience includes people who edit photos on their phones, make sure the product works well with Lightroom Mobile.
You don’t need to create multiple versions simply because you can.
Create the versions your actual target audience needs.
Example 3: A Notion Template
A Notion template isn’t a collection of lessons or presets.
Its content is the system itself: pages, databases, views, relationships, and instructions.
So the planning process looks a little different.
1. Sketch the Structure First
Before opening Notion, map out the structure of your template.
You can do this on paper, with a simple diagram, or in a mind map.
Think about:
what the main page will be;
which pages connect to it;
which databases you need;
how information moves through the system;
what the user should do first.
It’s the same principle we’ve been using throughout this course:
plan first, build second.
Five minutes spent sketching the structure can save you hours of rebuilding later.
2. Add a “Start Here” Page
Don’t assume that customers will immediately understand how your template works.
Create a simple “Start Here” page that explains:
what the template is for;
where to begin;
what each main section does;
what can be customized;
where to find the key features.
A good template shouldn’t force the customer to figure everything out on their own.
3. Add Examples
Empty databases can make even a good template feel confusing.
Add a few realistic examples so the customer can immediately see:
what goes where;
how the database works;
how different pages connect;
what the finished workflow looks like.
The examples don’t need to be complicated.
They’re simply there to:
show the customer how the template is meant to be used.
One Principle Works for Every Format: Start Small
Whether you’re creating a course, a preset pack, or a Notion template, the same principle applies:
Your first version doesn’t need to contain everything.
Create the smallest version that already provides real value.
For example:
one complete module instead of five;
10 useful presets instead of 30;
one complete Notion workflow instead of an enormous productivity system.
Then test it.
If people use it, understand it, and find it useful, you can expand it later.
This follows the same idea we used in Part 1.
There, we tested the idea.
Now we’re applying the same principle to the product itself:
Build a small version → test it → get feedback → improve it.
You don’t need to know exactly what the final version will look like before you start.
You need to create a working version first.
Your Task Before Part 3
Before moving on, do three things.
1. Map Out Your Product
Take the format you chose in Part 1 and create a basic structure:
modules and lessons for a course;
the number and theme of presets for a preset pack;
pages, databases, and relationships for a Notion template.
Don’t try to make it perfect yet.
You just need a clear map of what you’re going to build.
2. Define the Outcome of Every Section
For every item in your structure, complete this sentence:
“After this, the customer will be able to…”
Not:
“Here I’ll explain…”
But:
“After this, the customer will be able to…”
This small change helps you look at the product from the customer’s perspective instead of your own.
3. Define the Minimum Version
Look at your structure and identify the smallest version that could already be useful and worth releasing.
That’s what you should build first.
Everything else can come later.
What’s Next?
In Part 3, we’ll finally move from planning to creating.
We’ll look at how to actually build your digital product, which tools you can use, and how to avoid spending money on expensive software when free or simple alternatives are more than enough.
You don’t need to build everything. You need to build the right things.
