Forem: drLacheheb

A Developer’s Framework for Finding and Validating Profitable SaaS Ideas

drLacheheb — Thu, 15 Jan 2026 08:15:08 +0000

Mindset Shift

The "Problem First" Mentality

To find good SaaS ideas, you need to change your focus.

What most people recommend is that you "find ideas". Not only is this advice that's hard to act on with no clear direction, but it's advice that can typically lead someone astray.

What you need to do instead is focus on finding problems that people have.

Once you've found a problem, it's pretty easy to come up with ideas on how to solve it!

Time & Money

Hands down, focusing on problems is the fastest way to getting paid.

Here's why: problems themselves are grounded in 2 things - time and money spent. Solve either one of these with your product and people will be inclined to pay for your solution.

Real-World Example

Let's talk about the Time Spent aspect. And let's imagine you're a Graduate Student Researcher.

As part of your research, you have to do a lot of interviews with people. And part of that requires that you transcribe your interview recordings into text.

Researchers probably have a lot of other things to do and take care of. Spending hours transcribing an interview can cut into the time they need to work on other things. Here, they are experiencing the problem of spending a lot of time doing something that most don't find enjoyment in.

Let's say you want to instead outsource the work to a third-party to transcribe. You would have various options to go about doing it, but what you'll notice is it's pretty pricey to go this route.

What are your other options? Well, I'd say a solution where they don't spend a lot of money and where it would cut down on the time it takes them to transcribe their recordings. Automatic transcription software is a viable option if you aren't able to spend too much money, and are willing to put in some time to transcribe the audio into text.

Start paying attention to the problems that people are facing. Get a pulse on what people are saying they struggle with. From there, you'll be able to identify problems, which in turn can become products that solve those problems!

Methods for Finding Ideas

The Job Search Method

The Job Search Method is deeply grounded in finding problems that people have. It will lead you right to the problems that people have.

Step 1 - Find an Industry
Before finding problems, we have to choose an industry. I like to use this website when trying to find an industry to explore. There are TONS of industries to choose from. Take some time to go through the list read up on Wikipedia pages or watch a few videos to learn how things operate in an industry.

Step 2 - Find Jobs Within That Industry
To find jobs in an industry, simply put the industry name right into a job search engine, such as Indeed. The term "car dealers" isn't a job, but what Indeed will do is show you jobs within that industry. This will be your starting point.

Step 3 - Pay Attention To The Job Description
After reading through a job description (e.g., "Service Manager"), pay attention to the terms that are the job responsibilities of that person and see if that job responsibility has any relevance to a software product.

Step 4 - Start Building Search Keywords Based On Your Findings
Here's the formula for creating a keyword to find potential SaaS ideas:
Job Responsibility PLUS the words "management software"

For example, as a Service Manager, you need to "ensure compliance with Health and Safety regulations". Combine that with "management software" and you get: "Health and Safety management software".

The App Store Method

App Stores are a great place to find SaaS ideas. They exist to solve problems for users of a particular platform, so it's pretty easy to find the ideas within them.

Step 1 - Choose an App Store
There are plenty of app stores you can choose from (Shopify, Apple, Salesforce AppExchange, Chrome, Google Play). I like to use the Shopify App Store.

Step 2 - Choose a Category
Select any category that interests you (e.g., marketing, customer support, inventory management).

Step 3 - Sort the Results
Sort the results of the apps in that category from top to bottom, based on review or installations. You want to be able to filter out the apps that are the most popular.

Step 4 - Find the 1 Star Reviews
Filter the reviews by the 1-star reviews. Pay attention to reviews where people discuss things that are severely lacking from the app. This is where the problems that users really care about will surface. Knowing these shortcomings will be your competitive advantage.

Step 5 - Use your findings to come up with a SaaS Idea
Instead of flat-out imitating the popular app, focus on building an app that solves the main problem AND solves the specific problems you've identified in the bad reviews!

The Excel/Spreadsheet Method

This involves looking for what people are using Microsoft Excel or Google Sheets for.

Listen to what people use spreadsheets for
If you're into this, start paying attention to what people are using Excel for in their day-to-day jobs. As described in the first method, you can ask clarifying questions when people describe what they do at their jobs. If a task they mention sounds like they might be using spreadsheets for it, just ask them "what software do you use to do that?".

Two things will happen:

They will tell you about a piece of software they use to solve that problem for them.
They will tell you that they have a spreadsheet to help them solve that problem.

If they talk about using spreadsheets for that task, you could find out further if software would make their lives easier and if that is something they (or their company) would pay for!

Validating Your Idea

The Keyword Research Method

The goal is to find keywords that people are searching for that will surface your SaaS idea.

Enter your SaaS idea into Google Keyword Planner
Use the Google Keyword Planner (requires a free Google Ads account). Enter your keyword (e.g., “health and safety management software”). Google will give you a range of numbers based on the number of searches that happen per month and the price per click. Generally, the higher the number, the more people are searching for a solution.

Enter your keyword into Google Search
Enter the keyword yourself into Google Search. To further validate your idea, look for:

Ads appearing for your keyword.
Top organic results showing similar software.

If your search shows either of these, it’s a pretty safe bet to say that people are looking for this type of solution.

Using UberSuggest

I want to introduce another tool you can use that is free and doesn't require you sign up for an account. It's called UberSuggest! It's a keyword research tool much like the keyword planner, where you can enter your terms and get the same information, such as search volume. Try it out here.

The Question Research Method

This method validates the idea, uncovers competitors, and helps find Q&A content for your SEO strategy.

Step 1 - Start with a "What" question
Simply enter the search term: "What is (your SaaS idea)".
For example: "What is Health and Safety management Software?".

Pay attention to:

New Keywords: E.g., "Health and Safety Software" is also known as EHS Software.
Competitors: If a company like Cority.com pops up, it validates that this is something people purchase.

Step 2 - Repeat the process with the other "W" Questions
Ask further questions like:

How does EHS software work?
Where does EHS software get used?
What industries use EHS software?
Who uses EHS software?

With questions like these, you'll start to uncover more competitors and potential avenues of breaking into the market.

Execution & Strategy

Building the MVP (Minimum Viable Product)

Now that you've validated the idea, it's time to build the first version. Focus on building the core functionalities and getting it out there as fast as possible.

Why speed matters:

Testing: It lets you test the market to see if people really do want your product. You can even start off with just a waitlist sign up.
SEO: While you are building your product, search engines like Google will already know you exist.

Eww Sigma Devs Don’t Write Commits

drLacheheb — Wed, 30 Apr 2025 09:02:41 +0000

Ever stare at your staged changes in Git and feel your soul leave your body at the thought of typing yet another commit message? Same. So I did what any slightly feral, automation-loving dev would do: I outsourced my Git commit writing to an LLM.

The idea is stupidly simple:

Copy your git diff or staged patch.
Paste it into an LLM with a very aggressive system prompt.
Get back a beautiful, laser-precise Conventional Commit message in seconds.

No filler. No overthinking. Just fix: remove null check-level clarity.

How it works

Here’s the system prompt I use (I feed it to Gemini, but you can use whatever LLM you vibe with):

You are an AI assistant specialized in generating Git commit subject lines that strictly follow the Conventional Commits specification. Your sole task is to take a user’s description of code changes and produce only the <type>: <description> portion of the commit message. First, determine the most appropriate type from: feat, fix, chore, docs, style, refactor, perf, test, or build. Then, generate an extremely concise description in imperative present tense (e.g., “add”, “remove”, “update”), starting with a lowercase letter and without a trailing period. The description must state only the action performed and the primary object affected, explicitly excluding adjectives or contextual terms that describe the previous state (e.g., “unused”, “old”, “redundant”, “unnecessary”, “existing”). For example, if the user says “removed the unused variable foo,” the correct output is “remove foo variable,” not “remove unused foo variable.” Finally, output only the <type>: <description> string, without scope, breaking change indicators, body, or footers.

Example time

Say you’ve got this diff:

- const oldValue = 5;
- // was used in previous implementation
+ // removed unused constant

Paste it in, and boom — Gemini (or ChatGPT) gives you:

refactor: remove oldValue variable

No thought. No fluff. No regrets.

Why this rocks

✅ No more commit anxiety
✅ Always Conventional Commits-compliant
✅ Commit messages finally make sense when reviewing PRs
✅ Let’s be honest, writing good commit messages manually is kind of mid

TL;DR: Let the robots do your commits

You’ve already written the code. You’ve already pushed your brain to the limit. Why also write the summary like it's a haiku contest?

Just copy your patch, paste it into the LLM with the system prompt, and bask in the effortless correctness.

Be sigma. Never write a commit message again.

Would you like a downloadable snippet or CLI version of this workflow?

TypeScript with React Components ?

drLacheheb — Wed, 11 Sep 2024 15:30:00 +0000

In this post, I'm going to discuss why and how to use TypeScript to type React components.

You'll find how to annotate component props, mark a prop optional, and indicate the return type.

1. Why typing React components?

TypeScript is useful if you're coding middle and bigger size web applications. Annotating variables, objects, and functions creates contracts between different parts of your application.

For example, let's say I am the author of a component that displays a formatted date on the screen.

interface FormatDateProps {
  date: Date
}

function FormatDate({ date }: FormatDateProps): JSX.Element {
  return <div>{date.toLocaleString()}</div>;
}

According to the FormatDateProps interface, the component FormatDate accepts the date prop as an instance of Date. This constraint is crucial because the FormatDate component uses the date.toLocaleString() method, which only works with date instances.

Now, the user of the FormatDate component must satisfy this constraint:

<FormatDate date={new Date()} />

If the user passes a string to date instead:

<FormatDate date="Sep 28 2021" />

TypeScript will show a type error, ensuring you catch this issue during development.

2. Typing props

One of the best benefits React gains from TypeScript is prop typing.

Typing a React component is typically a 2-step process:

A) Define the interface that describes the component props.

B) Annotate the props parameter in the functional component.

For example:

interface MessageProps {
  text: string;
  important: boolean;
}

function Message({ text, important }: MessageProps) {
  return (
    <div>
      {important ? 'Important message: ' : 'Regular message: '}
      {text}
    </div>
  );
}

Now, when rendering Message, props must match the defined types:

<Message text="The form has been submitted!" important={false} />

2.1 Props validation

If you provide incorrect props, TypeScript will show a type error during development:

<Message text="The form has been submitted!" important={0} />

2.2 children prop

The children prop holds the content between the opening and closing tags of a component:

<Component>children</Component>

To type the children prop:

interface MessageProps {
  children: JSX.Element | JSX.Element[];
  important: boolean;
}

function Message({ children, important }: MessageProps) {
  return (
    <div>
      {important ? 'Important message: ' : 'Regular message: '}
      {children}
    </div>
  );
}

You can now pass children like so:

<Message important={false}>
  <span>The form has been submitted!</span>
</Message>

or with multiple elements:

<Message important={false}>
  <span>The form has been submitted!</span>
  <span>Your request will be processed.</span>
</Message>

Challenge: How would you update the MessageProps interface to also support a string value as a child?

2.3 Optional props

To make a prop optional, use ?:

interface MessageProps {
  children: JSX.Element | JSX.Element[];
  important?: boolean;
}

function Message({ children, important = false }: MessageProps) {
  return (
    <div>
      {important ? 'Important message: ' : 'Regular message: '}
      {children}
    </div>
  );
}

Now you can skip the important prop:

<Message>
  <span>The form has been submitted!</span>
</Message>

3. Return type

TypeScript can infer the return type of a React functional component, which is usually JSX.Element:

function Message({ children, important = false }: MessageProps): JSX.Element {
  return (
    <div>
      {important ? 'Important message: ' : 'Regular message: '}
      {children}
    </div>
  );
}

If the component may return null, use JSX.Element | null:

function ShowText({ show, text }: { show: boolean, text: string }): JSX.Element | null {
  return show ? <div>{text}</div> : null;
}

3.1 Tip: enforce the return type

It's recommended to explicitly set the return type:

function BrokenComponent(): JSX.Element {
  return
    <div>Hello!</div>; // Error caught!
}

Feel free to comment below if you have any thoughts or questions!

A Simple Guide to Component Props in React

drLacheheb — Wed, 11 Sep 2024 07:56:48 +0000

To start using React, you don't need to learn a lot. Master the concepts of components, state, props, and hooks, and you'll be on your way.

1. The Component Props

A component is an encapsulated piece of logic. For instance, here's a simple component that displays a "Hello, World!" message:

function HelloWorld() {
  return <span>Hello, World!</span>;
}

// Render
<HelloWorld />

// Output
<span>Hello, World!</span>

The problem with <HelloWorld /> is that it is inflexible. You cannot change the greeting person, e.g., use "Joker" instead of "Earth."

You can solve this issue using component props.

Let's enhance the <HelloWorld /> component by adding a prop who to customize the person being greeted. We'll rename the new component to <Hello>.

There are 2 steps to add the who prop to the <Hello /> component:

Make the function of your component read the props from the props parameter:

   function Hello(props) {
     return <div>Hello, {props.who}!</div>;
   }

Now the Hello function has a props parameter. React will ensure that the props object contains all the props you assign to the component.

When rendering the component, add the prop using attribute-like syntax:

   // Render
   <Hello who="Earth" />

   // Output
   <div>Hello, Earth!</div>

You can use any value for the who prop. For example, let's greet "Mars":

   // Render
   <Hello who="Mars" />

   // Output
   <div>Hello, Mars!</div>

That's all you need to know to use React props!

1.1 Multiple Props

You can use as many props as you like. For example, let’s make the <Message /> component accept 2 props to customize the greeting message and the person:

function Message({ greet, who }) {
  return <div>{greet}, {who}!</div>;
}

// Render
<Message greet="Welcome" who="Aliens" />

// Output
<div>Welcome, Aliens!</div>

1.2 Class Component Props

If you use class-based components, you can access the props from this.props:

import { Component } from 'react';

class HelloAsClass extends Component {
  render() {
    return <div>Hello, {this.props.who}!</div>;
  }
}

// Render
<HelloAsClass who="Earth" />

// Output
<div>Hello, Earth!</div>

2. Values of Props

Props can be various types of values, including numbers, booleans, objects, arrays, and even variables. React doesn't restrict prop values but requires non-string literals to be wrapped in curly braces:

String literals:

  <MyComponent prop="My String Value" />

Template literals with variables:

  <MyComponent prop={`My String Value ${myVariable}`} />

Number literals:

  <MyComponent prop={42} />

Boolean literals:

  <MyComponent prop={false} />

Plain object literals:

  <MyComponent prop={{ property: 'Value' }} />

Array literals:

  <MyComponent prop={['Item 1', 'Item 2']} />

JSX:

  <MyComponent prop={<Message who="Joker" />} />

Variables:

  <MyComponent prop={myVariable} />

3. Passing Down Props

Inside a component, you can use props like any regular JavaScript variable. You can render conditionally or pass props to other components.

For instance, let’s create a <HelloPeople /> component that accepts a list of persons and passes each person to the <Hello /> component:

function HelloPeople({ persons }) {
  return (
    <div>
      {persons.map((person, index) => (
        <Hello who={person} key={index} />
      ))}
    </div>
  );
}

// Render
<HelloPeople persons={['Joker', 'Batman']} />

// Output
<div>
  <div>Hello, Joker!</div>
  <div>Hello, Batman!</div>
</div>

4. Optional Props

Sometimes you have a good default value for a prop. You can omit the prop and specify a default value inside the component:

function HelloOptional({ who = 'Unknown' }) {
  return <div>Hello, {who}!</div>;
}

// Render
<HelloOptional />

// Output
<div>Hello, Unknown!</div>

// With specified prop
<HelloOptional who="Batman" />

// Output
<div>Hello, Batman!</div>

5. Props Spread Syntax

If you dynamically construct the props of a component, you might use a plain JavaScript object:

const hiBatman = { greet: 'Hi', who: 'Batman' };

function Message({ greet, who }) {
  return <div>{greet}, {who}!</div>;
}

// Render
<Message {...hiBatman} />

// Output
<div>Hi, Batman!</div>

6. Special Props

While you can use any prop names, React has some properties with special uses:

6.1 `children`

children is a special property assigned by React with the content of the component:

function Parent({ children }) {
  console.log(children); // logs <span>I'm a child!</span>
  return <div>{children}</div>;
}

// Render
<Parent>
  <span>I'm a child!</span>
</Parent>

// Output
<div><span>I'm a child!</span></div>

6.2 `key`

The key prop helps React identify which items have changed, are added, or are removed:

function HelloPeople({ persons }) {
  return (
    <div>
      {persons.map((person, index) => (
        <Hello who={person} key={index} />
      ))}
    </div>
  );
}