DEV Community: James Hubert

12 Products in 12 Months - Starting today

James Hubert — Sun, 06 Jul 2025 14:52:55 +0000

Background: The Long Tail Effects of Cowardice

Hi friends. It's James again. Today is my birthday and I feel I don't have a lot to show for it. Five years ago, in 2020 I posted on Dev.to about creating 100 React projects in 100 days (link here) to learn front end development and get a full time job in the industry.

That mini-marathon of React projects got me some retweets from indie dev sites and the Dev.to community, and a little notoriety in the self-taught Javascript learner space. The projects repo (link) has 94 stars on it and 44 forks, which is cool, I also eventually did get a full time software engineering job at a startup, in part because someone in my network had seen the posts. It led to some really fruitful things and a whole career in the industry, plus eventually a web development business that 100% financially supported me while I lived abroad.

But honestly I've been thinking of building digital products since I was 19- 15 years ago- and I've never done it. In large part because I didn't have the skills, but mostly because I didn't have the guts. Rather than drop out of college and learn app development like I wanted to after my first visit to the Bay Area in 2011, I stayed in college because I didn't have the guts.

Rather than drop everything, be poor for a while, and learn to code after college like I wanted to in 2014 I went into software sales because I didn't have the guts. Rather than go full-time on a startup idea in 2015 like I wanted to, when I started learning Swift, I stayed working full-time because I didn't have the guts. And over the last four and a half years since I made those React projects to learn to code in 2020 I never made any of the products I wanted to build because I wanted to get a software engineering job and feel validated instead, because I didn't have the guts.

Well I'm a lot more competent with code now. I know React + NextJS and styling tools like Tailwind pretty reflexively. Deployment is a breeze and so is CI/CD. I also know Flutter for mobile dev pretty well at this point. So there's no reason to avoid it any longer. Plus I have a job and can financially support myself which, frankly, is a big deal when you're trying to confidently contribute to your side projects.

Today I'm starting 12 products in 12 months, something I honestly thought about doing all the way back in 2020 and has been bouncing around my head since then. Most of what I plan to make has also been with me that long, or are things I've thought of over the years since. It's time to put these things out into the wild.

So, What Is A Product?

What is a product? Let's define our terms. A product is something that exists in the world which people can purchase. So unlike the React projects, if the project isn't complete and if it can't accept payment then I've failed. That's why I'm giving myself a whole month per project rather than just a day 😉

And a product has to be a complete service. Whatever it claims to provide, it does its damned best to provide it to keep its users happy and keep them coming back. In this realm we go from incomplete best-effort projects to minimum viable products. So that's the definition. They definitely don't have to be perfect, but if they aren't feature-complete, then it doesn't count.

The first product - Texas Trades

Link - www.gotexastrades.com

OK, what am I building between this very moment and August?

The first product I have already been working on is a mobile-first service which is a Linkedin alternative for the fast growing blue collar industry, focused on the booming Texas job market. I've thought a lot about this over the last few years. I even considered buying the domain whythetrades.com way back in 2019 when I first started thinking about this:

I've often wondered why high paying, stable blue collar jobs are considered so much less prestigious in the US than jobs that pay a lot less and are frankly easier that require a college degree. In countries like Germany and Canada, the trades and white collar work are treated with similar reverence. You're working afterall- and providing a valuable service. That's prestigious and awesome in itself.

Plus, the job market is changing. With AI coming to displace the white collar world, college degrees not paying anywhere near what they used to, and the very real phenomena of US companies farming out their creative tasks to highly capable overseas workers willing to work for less, I think smart Americans will start to understand that prestige of a job and its market value aren't really aligned in 2025, and to take the trades seriously.

A very real question exists- why would someone take out $200k in student loans just to get a $50k per year job four years later if they can join an apprenticeship when they're 18, accrue zero debt, and be making well over six figures before they're 23 years old?

So that's what I'm working on. A professional network for blue collar folks who maybe have never owned a computer, possibly never even made a resume, never had a Linkedin or don't want to read inspirational articles about digital marketing when they're bending a pipe or lifting a steel girder. But the main thing that I think these people deserve- a job board that doesn't require you to write your own resume with Microsoft Word and doesn't force you to create an individual account per application, and fill out a 10 page Workday or Oracle form with 90% of the same answers every time. This process should be eradicated and the companies who use those HR tools should be ashamed. Here are some screenshots from the UI I've got done so far:

The Inspiration

I won't lie to you, and those in the indie maker space probably already know I'm copying the 12 products idea from famous indie hacker Pieter Levels. It's just coincidental that I also heard about and was inspired to make my 2020 list of React projects from Jennifer Dewalt's 120 websites in 120 days and I've been following his career since 2022.

I have a separate problem from Pieter though, which is a bone to pick with my own mind. I've had hundreds of ideas over the course of my professional life and have hardly made any of them. This is ridiculous and has led to me being a dreamer rather than a doer, which no one wants to be. And I'm too old now to be walking around with a bunch of ideas that are exciting that I've made no progress on. That's how you get old- not taking action. As Thoreau once wrote, "The youth gets together his materials to build a bridge to the moon, or, perchance, a palace or temple on the earth, and, at length, the middle-aged man concludes to build a woodshed". So I'm taking action to get out of that hole.

The Process

Simple. Each Sunday night I write a blog post documenting my progress on whatever product I'm working on. My KPI's are documented each week with a binary checkbox:
✅ Shipped?
✅ Marketed?
✅ Accepts Payments?
✅ Collected Feedback?
✅ 2nd Version Shipped?

I'll also be using the handy tool WIP.co - a maker tool for developers to track their progress. Here's my link over there:
https://wip.co/@well_akshually

Wish me luck!

My last project for 100 React projects in 100 days

James Hubert — Tue, 23 Apr 2024 16:36:40 +0000

Hey! I'm on a mission to make 100 React.js projects. Please follow my dev.to profile or my twitter for updates and feel free to reach out if you have questions. Thanks for your support!

Link to today's deployed app: Link
Link to the repo: github

I'm writing you today to talk about failure, and the nature of success. I don't feel bad about it. There are people out there who believe in positivity like a religion (they are mostly in sales and marketing), they do not like to acknowledge failure. They fake it til they make it and see themselves as being perpetually better than all competition as a mindset (a.k.a. a "grindset").

That is not me. I am grounded in reality and believe in plain speaking. And all roads to success are paved with failure.

On Halloween of 2020 at the height of the pandemic in New York City I sat alone in my Brooklyn apartment and dedicated myself to doing 100 React projects in 100 days. It was one of the harder things I had ever done, but I knew it would force me to learn. Every day I made a new project in React, usually based on some concept I was learning in tutorials or on Youtube or from a blog, then I would blog about it.

The whole process probably took about 4 hours per day on average. Both the projects and the blog posts ended up taking equally large amounts of time. For this reason eventually (around project 25 I believe) the space between projects slowed from every day to every other day, and so on.

In this time I also ended up getting referred to a full time job and around project 80 I basically stopped doing the projects altogether. So now, 3 and a half years later I'm writing the final blog post for the 100 projects. Better to finish something you've started than not, even if it's late, no?

The last project I made in React, which I actually made about a year and a half ago in the fall of 2022, was called Portful.co. It is a React project with Context API, Typescript, Firebase, and hosted on Netlify. The idea was to make a space online where developers and creatives could display their portfolio easily and elegantly without having to buy a domain and code their own website. I still think it's a good idea, but this project wasn't it.

At the end of the project I tested, launched it, and after over a month of working on it realized that not only was it poorly styled and not a great substitute for hosting online creative work, but also that Create React App apps have no SEO ability. Even after working on React for multiple years it had never dawned on me that React alone was literally a "Single Page Application". It's technically only one page with different Javascript components being showed in a page-like manner to users. But search engines can only index actual pages.

After probably 150 hours of work I gave up and abandoned all hope. A friend who is a senior developer mentioned that this is why people use NextJS or Gatsby.

It's pretty funny that after all that time working on React, and even passing coding interviews and having a full-time job, since I'd never tried to build a real product before I'd never thought of the ramifications of a lack of SEO. Previously, I had thought SEO was for marketers, and I wanted nothing to do with it.

Still though, in building the project I learned about all the time it takes to actually launch a new site that was (close to) complete. It has auth, a database, routing, and I actually got a few people to use it although they abandoned it quickly.

I also likely became a better developer. Building out request-response cycles and storing the successfully queries in local state became second nature.

To summarize the 100 projects as a whole, although completing it in 100 days was a failure, I did learn a ton through practice and experience- something tutorials can never teach you. And in the process of writing thoughtful blog posts, I was forced to communicate the concepts learned which also feeds into learning. If I could do it all over again, I would. Though next time I take on something like this I'll stick to the time limit I do it in.

If you're interested in pursuing something like this, I recommend you go for it. There's nothing stopping you. By publishing your projects publicly you get social accountability, and by completing it you learn what you're made of. Most of all, by setting hard goals and attempting to achieve them, you learn about both the technology you're practicing and yourself through failure- which is the greatest teacher.

Thanks to everyone who supported me along the way. There's much more to come 🙏

If you like projects like this and want to stay up to date with more, check out my Twitter @jameshubert_com, I follow back! See you tomorrow for another project.

Intro to Python: Day 19 - Building a Dictionary

James Hubert — Tue, 29 Aug 2023 14:35:00 +0000

Hi there 👋 I'm a New York City based web developer documenting my journey with React, React Native, and Python for all to see. Please follow my dev.to profile or my twitter for updates and feel free to reach out if you have questions. Thanks for your support!

Dictionaries are an essential building block in programming and a fundamental data type in most languages. In Python, we can build a dictionary simply by declaring an empty one.

state_population_dict = {}

We can then add to it by explicitly naming a key-value pair. Here we are adding states to our state_population_dict dictionary with their respective populations:

state_population_dict["WA"] = 7739000
state_population_dict["NY"] = 19840000

We can then check the value of a key in the dictionary simply by calling the dictionary with the key in brackets.

print(state_population_dict["WA"])
# prints 7739000

If we try to check the value of a key that does not exist on the dictionary, we will get a KeyError which states the key does not exist on the dictionary.

To check if a key exists on the dictionary before requesting to get its value, we can use the in keyword.

if ("TX" in state_population_dict):
    print(state_population_dict["TX"])
else:
    print("TX population not in dictionary")

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 18 - Running Your First Python Program

James Hubert — Mon, 28 Aug 2023 12:57:00 +0000

To run a program in Python, luckily it's quite a bit easier than learning to run your first program in Javascript, for which you have to learn Node.

Simply make sure Python is installed on your computer by opening a terminal and typing python or on Mac/Linux systems it is likely python3, which it is for me. If you get an error, go to the Python website and download it to your machine. Once installed, running python3 should print the following:

Python 3.9.6 (default, Oct 18 2022, 12:41:40) 
[Clang 14.0.0 (clang-1400.0.29.202)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

To run your own Python program simply create a folder, and save a Python file in it by using the extension .py. For example, main.py.

Let's start traditionally and write a Hello World program.

#main.py
print("Hello world!")

When you save this program and in the command line run python3 main.py from the project directory, your string will print to the screen. Huzzah!

This means it is installed and the three > mean it can accept input. You can stop the interpreter by pressing CTRL + D on a Mac.

When you verify Python is installed (

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 17 - Making Dumb Mistakes with Lists []

James Hubert — Thu, 24 Aug 2023 12:36:36 +0000

One of the things I've found most helpful about Python so far is the error messages. Whenever your program crashes, you get a full traceback message of all the places in the code where the program failed.

If you scroll to the bottom of the traceback, you'll see the first place in the code it failed- which is the first bug it encountered that needs to be fixed. Python will also try to print out an exception that indicates what kind of bug it encountered.

Today I encountered an IndexError while testing my program. Unlike Javascript, which will allow you to create a list by explicitly adding elements at a given index, Python is more strict, and will only allow this if the index already exists. This means that unlike in Javascript, the following Python code will crash:

my_list = []
my_list[0] = "apple"
print(my_list[0])

# console will print:
# ERROR!
# Traceback (most recent call last):
#  ...
# IndexError: list assignment index out of range

This is because although the my_list list exists, there is no index 0 on it, so in Python we cannot simply add something there if it doesn't exist.

Javascript is more forgiving because it's made for working with browsers and the web. It does its best to help you. Python will not, but that's ok, because it's more frequently used for backend computations and more precise programs.

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 16 - OOP - Overriding ==, >, and <

James Hubert — Wed, 23 Aug 2023 13:22:24 +0000

Today we follow up on yesterday's post about overloading the built-in print method. This time, we're overloading ==, >, and < operators.

It's always useful to be able to compare things, and it's somewhat natural that two instances of the same class might be able to be compared. But the built-in functionality for those operators is to compare either numbers or strings, not classes.

Let's say we are a car dealership and we want a program that can help us figure out quickly what the value of different cars is. We want to just quickly compare them.

Obviously if I create a Car class and then compare two instances of that class, we'll just get an error. Like so:

class Car:
    def __init__(self, make, model, price):
        self.make = make
        self.model = model
        self.price = price

mustang = Car("Ford", "Mustang", 60000)
camaro = Car("Chevy", "Camaro", 50000)

print(mustang > camaro)

# Will print the following:
# ERROR!
# Traceback (most recent call last):
#  File "<string>", line 12, in <module>
# TypeError: '>' not supported between instances of 'Car' and # 'Car'
>

So to create method on this class that overrides the built-in functionality so that we can compare these Car class instances, let's use the built-in eq, gt, and lt methods.

class Car:
    #...
    def __eq__(self, target):
        if (self.price == target.price):
            return True
        else:
            return False

    def __gt__(self, target):
        if (self.__eq__(target) == True):
            return False
        elif (self.price > target.price):
            return True
        else:
            False

    def __lt__(self. target):
        if (self.__eq__(target) == True):
            return False
        elif (self.__gt__(target) == True):
            return False
        else:
            return True

By using the built-in eq, gt, and lt keywords we can tap into this functionality and define our own behavior for ==, >, and <.

So now if we compare two cars:

mustang = Car("Ford", "Mustang", 60000)
camaro = Car("Chevy", "Camaro", 50000)

print(mustang > camaro)
print(mustang < camaro)
print(mustang == camaro)

We get the result:

True
False
False

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 15 - OOP - Overriding the Print Method on a Custom Class

James Hubert — Tue, 22 Aug 2023 13:00:26 +0000

So every programming language has its own built-in behavior for printing different kinds of objects. In Python, if you have a custom class, printing an instance of the class will simply print a pointer which indicates its place in your storage. It's pretty useless.

class Animal():
    def __init__(self, type):
        self.type = type

lion = Animal("lion") 

print(lion)

# prints "<Lion object at 0xa0acf8>"

(Note: This example is adapted from the super duper helpful OOP course at dev.to)

So, if we want to override the built-in print functionality, all we need to do is specify it using the built-in instance method __str__().

class Animal():
    def __init__(self, type):
        self.type = type

    def __str__(self):
        return f"I am a {self.type} type of animal."

lion = Animal("lion") 

print(lion)

# prints "I am a lion type of animal."

Pretty cool eh? If you're working extensively with custom classes, having them be able to show useful information when printed can be useful.

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 14 - OOP - Method signatures in polymorphism

James Hubert — Mon, 21 Aug 2023 14:32:04 +0000

We're following up on yesterday's article on polymorphism with a brief discussion of function and method signatures and best practices in Python inheritance.

As discussed, polymorphism is the ability for multiple different classes, with different methods and data, to inherit from the same parent class. This makes it easier to create new classes that share methods that are on the parent.

In computer programming, a function signature is a term for the inputs and outputs of a function. To use the boot.dev definition in OOP Chapter 5 on Polymorphism:

A function signature includes the name, inputs, and outputs of a function or method.

In functional programming, each function is recognized to have its own distinct function signature, and there is no inheritance as such. In OOP, inheritance is one of the major benefits.

This means we need to take care though not to confuse users of our code, especially when overriding methods on child classes. So, it is a best practice NOT to change the method signature of a class method which inherits from a parent, even when overriding the method.

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 13 - OOP - What is polymorphism? 🧐

James Hubert — Sun, 20 Aug 2023 13:33:47 +0000

Today we follow up on a series of posts about Object Oriented Programming in Python. You can check out yesterday's article here.

We've been talking about inheritance in OOP recently, and yesterday's blog post discussed how a child class can inherit variables and methods from a parent class. This is useful if you want the same behavior in a child that a parent has.

But what if you want different behavior in the child class than a parent has, but want to inherit everything else? This is where polymorphism comes in.

Let's say you have an Organism class. Just like in biology, all animals and plants are types of organisms. So we might have a eat() method on the organism class (all organisms like to eat!).

On the parent Organism class the eat method look like this:

class Organism:
    def __init__(self, name):
        self.name = name

    def eat(calories):
        print(f"{self.name} ate a meal of {calories} calories")

In the above class, we have a constructor function where we can pass in a name and an instance variable name that we set it to. So now our organism has a name! In the eat method, we pass in a number of calories and our method prints out how many calories it ate.

Let's say our organism is a plant. Plants don't eat food like you and I do, instead they get their food from the sun and convert it to energy. So eating calories doesn't make sense for a Plant class, even if it inherits from the Organism class. So instead we want to inherit everything else from Organism but the eat() method should accept a hours_of_sunlight argument instead of calories.

Our Plant class might look like this:

class Plant(Organism):
    def __init__(self, name, type):
        super().__init__(name)
        self.type = type

    def eat(hours_of_sunlight):
        print(f"The {self.type} plant converted {hours_of_sunlight} hours of sunlight into energy!")

In the above example, the Plant class calls the parent's constructor function using super().__init__() in its constructor, thereby inheriting the name variable and setting it, which is awesome!. We also set a new instance variable called type where we can pass in things like "palm tree" or "sunflower" or "green ivy".

After creating an instance of Plant the eat method would be available on it the instance because it would come from the parent. But as we said we want the Plant class' eat method to be different! So to do this we simply create a new method on the Plant class with the same name- eat().

Now, when an instance of Plant is created and its eat method is called, instead of printing a line about how many calories it consumed, we describe how many hours of sunlight it converted into energy!

This ability to selectively inherit data and methods from the parent but also take on a new form if need be, by overwriting methods and variables inherited from the parent, is called polymorphism.

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 12 - OOP - Calling a parent method

James Hubert — Sun, 20 Aug 2023 03:22:44 +0000

Today is another article on the concept of Object Oriented Programming in Python.

The fact that a child class can inherit data through variables, and actions through methods, from a parent class is a main reason why OOP is powerful. This is called single inheritance and refers to a direct relationship from parent to child class.

In order for a child component to inherit a parent component's methods, you must first instantiate the child Class with the parent's constructor using the super() method. For example, let's say a Truck class inherits from a Vehicle class:

class Vehicle:
    def __init__(self, color):
        self.color = color

    def get_color(self):
        return self.color

class Truck(Vehicle):
    def __init__(self, color, horsepower):
        super().__init__(color)
        self.horsepower = horsepower

Here we see that we use the super() method to call the parent's constructor function. But this method is built in. Now let's say we want to get the color of the truck using the parent's get_color() method. In order to call it, we must use the super() method again, but this time for a non-built-in method.

class Truck(Vehicle):
    def __init__(self, color, horsepower):
        super().__init__(color)
        self.horsepower = horsepower

    def compliment_car(self):
        truck_color = super().get_color()
        print(f"Hey love that {truck_color} truck you have!")

This is how we can use the parent Vehicle's get_color() method on the child Truck class.

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 11 - Another Class Inheritance Example

James Hubert — Thu, 17 Aug 2023 13:41:38 +0000

Today in my journey with boot.dev I encountered a fun problem that we solved using OOP and class-based inheritance.

A rectangle is a shape with four sides where the length of the sides is equal and the length of the top and bottom are equal, but the top and bottom don't need to be equal to the length of the sides.

A square is a type of rectangle, but all four sides must be the same length.

So, if we make a Rectangle class to get the perimeter and area of any given rectangle, where we need to input the length of the x-axis sides and the length of the y-axis sides in order to get that information, like so:

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def get_area(self):
        return self.length * self.width

    def get_perimeter(self):
        return (self.length + self.width) * 2

...then we should be able to quickly build a Square class that inherits these methods but is automatically instantiated using only the length of one of its sides (since all sides of a square are the same length):

class Square(Rectangle):
    def __init__(self, length):
        super().__init__(length, length)

Behold, the power of OOP! Unlike dragons and cars and other fairly non-sensical use cases, I could see actually using something like this if I were, say, building a house, maybe. Idk.

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.

Intro to Python: Day 10 - Basic Operators in Python vs Javascript

James Hubert — Mon, 14 Aug 2023 00:11:02 +0000

As a developer with a basic background in Javascript, it can be confusing at times learning Python and completing exercises in a course because the syntax is so readable in Python, and so similar to JS, but not the same.

Every development language will have logical operators, and they will follow a simple AND, OR, NOT syntax.

In my native Javascript however, AND is demarcated with &&, OR is demarcated with || and NOT is demarcated with !. These are readable and short. They're so easy to get used to it can be tough to transition out, especially when Python's logical operators ==, !=, >, >= and so on are nearly identical to Javascript's.

In Python, those operators are simple English: and, or, not. They're so simple it's easy to forget them! Which is the easiest way to get a bug you have no idea how to solve.

Onward and upward!

If you like projects like this and want to stay up to date with more, check out my Twitter @stonestwebdev, I follow back! See you tomorrow for another project.