Dom Vacchiano

How We Grew BPIQ to 27K Followers | From Crickets to Community

Mon, 13 Oct 2025 02:10:00 GMT

This is the story of how we grew BiopharmIQ from 1K to 27K followers.

The Early Days (2021)

BiopharmIQ started as a simple idea: provide needle-moving data to biotech investors.

We used X as a platform to reach potential users, but for the first year, we were posting into the void.

BiopharmIQ had barely 1,000 followers, and it felt like shouting into an empty room.

If you’ve ever tried to build an audience online, you know the feeling: you put in the work, you post consistently, and... nothing.

Our tweets were factual, technical, and... lifeless. We were “informing,” not connecting. The follower count barely moved all year.

As you can see from the below posts, blocks of information, no images, etc.

The Expansion (2022)

In January 2022, we decided to try X ads.

It worked, sort of. Our follower count exploded. We gained thousands of new followers in a few months.
But something felt off.

Engagement didn’t move. We had a big audience, but it felt like a room full of ghosts.
No one was replying, no one was discussing, and no one seemed to care.

That’s when it hit me: follower count is a vanity metric unless it reflects real engagement.

We turned off the ads later that year, grateful for the experiment but realizing we hadn’t built what we truly wanted, a community.

The Turning Point (2023)

Then came the shift.

In January 2023, I bought Dagobert’s "How to Dominate Twitter" course. It completely reframed how I thought about the platform, and honestly, about the internet in general.

Social media is just like real life:
Give twice, ask once.
Make real connections, not superficial ones.
Provide value, and people will find you.

Those ideas clicked immediately.

We stopped treating Twitter like a broadcast channel and started treating it like a conversation.
Instead of chasing algorithms, we focused on people.

Here’s what changed:

We focused on providing high-value insights, not marketing blurbs.
We engaged with others who cared about the same space.
We amplified other voices doing great work.
We spoke like humans, not analysts.

And that’s when everything started to move again.

The Growth That Mattered (2023–2024)

If you look back at the chart, you can see the second inflection point in early 2023, the slope climbs again, but this time it means something.

From 2023 to today, our followers grew from 10,000 to 27,000.
But more importantly, the feel of the community changed.
We started seeing real conversations, thoughtful replies, and collaborations that grew organically.

The page felt alive.

BiopharmIQ was no longer just an account, it was piece of the biotech Twitter ecosystem.
We were learning, sharing, and growing alongside our audience.

The Principles That Made It Work

Looking back, the growth wasn’t magic. It was mindset.

Here are the four principles that changed everything:

Give more than you take.
The algorithm rewards value, because people do.
Engage > broadcast.
Communities are built in the replies, not the timeline.
Authenticity scales slower, but lasts longer.
People remember your tone more than your stats.
Metrics are mirrors, not meaning.
They reflect what’s working, but they aren’t the goal.

We stopped chasing numbers and started nurturing relationships.
That’s when everything changed.

If you’re building a brand, a startup, or a personal platform online, remember this:

Every follower is a person.
And people don’t follow algorithms, they follow value.

That’s how BiopharmIQ grew from crickets to community.

Thanks for reading! If you’re interested in hearing more about my stories building and growing BPIQ, or using AI, follow along at @DomVacchiano.

Build a Stock Screener with Python (Part 3): Working with CSV Files

Tue, 22 Jul 2025 04:23:00 GMT

Let's get our data into CSV/Excel! Final GitHub Repo.

Final output:

In Part 2, we pulled biotech catalyst data into our stock screener using the BPIQ API. Up to this point we display the stock screener in our terminal. It would be more useful if we could save the data for future reference. In this walkthrough (Part 3) that's what we'll do.

We will read in data from a csv file and write/export our stock screener data to a separate CSV/Excel file..

If you haven't seen Part 2 (or Part 1), check them out. They are quick and will get you up to speed. However, you can grab the base code from GitHub and follow along starting from this Part 3 exercise.

Overview of Steps:

Create a CSV file with tickers of interest.
Update our main() function to ingest these tickers.
Update our get_catalyst_data() function to get BPIQ Big Movers.
Update our main() function to write our data to a csv file.

Creating a csv file with tickers of interest:

In Part 1 and Part 2 we read in tickers from a .txt file, but who uses .txt files? (I'll admit I sometimes do for quick notes - tisk, tisk). You probably store your stock portfolio in csv/excel files (hopefully G-Sheets).

First, create a new file in your project directory 'tickers.csv' and add in a row for each ticker and company name. Here is my example:

ticker, company
ARCT, Arcturus Tx
IONS, Ionis Pharma
FBIO, Fortress Bio
KALA, Kala Bio
HRMY, Harmony Bio
LRMR, Larimar Tx

Updating our main() function to ingest these tickers.

Let's update our main() function to read the tickers in from the csv file instead of the txt file:

First we want to import a built in python module 'csv' to handle interacting with our csv files, so at the top add:

import csv # <== NEW FROM PART 2
from datetime import date, timedelta
... # prev imports below

Next update the main() function to open the csv, read it into a DictReader object that is iterable and stores each row in a dictionary using the column header as the key. We need to also update the calls to the other functions to pass in the ticker:

def main():
    # with open("tickers.txt") as f:
    #     tickers = [line.strip().upper() for line in f if line.strip()]

    # NEW ====
    with open("tickers.csv", "r") as file:
        # creates an iterable object with a dictionary for each row using the headers as the key
        reader = csv.DictReader(file)
        ticker_data_list = []
        for row in reader:
            print(row)
            ticker_data_list.append(row)

    results = []
    for ticker_dict in ticker_data_list: # <=== UPDATE
        data = get_stock_data(ticker_dict["ticker"]) # <=== UPDATE
        catalyst_data = get_catalyst_data(ticker_dict["ticker"]) # <=== UPDATE
        results.append([
            data["Ticker"],
            format_number(data["Market Cap"]),
            format_number(data["EV"]),
            format_number(data["Cash"]),
            f"{data['EV/Cash']:.2f}" if data["EV/Cash"] else "-",
            catalyst_data # <== NEW FROM PART 1
        ])

    headers = ["Tickers", "Market Cap", "EV", "Cash", "EV/Cash", "Num Catalysts"]
    print(tabulate(results, headers=headers, tablefmt="pretty"))

Update our get_catalyst_data() function to get BPIQ Big Movers

Now let's update our get_catalyst_data function to filter for BPIQ Big Movers and also return more catalyst data (not just the count).

def get_catalyst_data(ticker):
    today = date.today()
    months_to_add = 3
    future_date = today + timedelta(days=months_to_add*30)

    # call to bpiq api ==== NEW - ADDED &mover=true to end >>
    url = f'https://api.bpiq.com/api/v1/drugs/?ticker={ticker}&catalyst_date_max={future_date}&mover=true'
    headers = {
        'Authorization': f'Token {credentials.BPIQ_API_KEY}'
    }

    response = requests.get(url, headers=headers)

    if response.status_code == 200:
        data = response.json()
        # ================ NEW ===============
        catalyst_data = []
        for result in data["results"]:
            catalyst_data.append({
                "drug_name": result["drug_name"],
                "indication": result["indications_text"],
                "catalyst_event": result["stage_event"]["label"],
                "catalyst_date": result["catalyst_date_text"],

            })
        print(catalyst_data)
    else:
        print(f"Request failed with status code {response.status_code}")
        return "-"
    
    return catalyst_data # <==== UPDATED

We updated our BPIQ API call to filter for Big/Suspected Movers, and also return a list of dictionaries containing catalyst details like drug, indication, event details, and timing.

Update our main() function to write our data to a csv file

We need to update our main function again, this time to write our data to a csv file. We will include the fundamental stock data and the catalyst data.

def main():
    # with open("tickers.txt") as f:
    #     tickers = [line.strip().upper() for line in f if line.strip()]

    # NEW ====
    with open("tickers.csv", "r") as file:
        # creates an iterable object with a dictionary for each row using the headers as the key
        reader = csv.DictReader(file)
        ticker_data_list = []
        for row in reader:
            ticker_data_list.append(row)

    results = []
    for ticker_dict in ticker_data_list: # <=== UPDATE
        data = get_stock_data(ticker_dict["ticker"]) # <=== UPDATE
        catalyst_data = get_catalyst_data(ticker_dict["ticker"]) # <=== UPDATE
        results.append([
            data["Ticker"],
            format_number(data["Market Cap"]),
            format_number(data["EV"]),
            format_number(data["Cash"]),
            f"{data['EV/Cash']:.2f}" if data["EV/Cash"] else "-",
            catalyst_data
        ])

    # ===== NEW ===
    with open("catalyst_data.csv", "w", newline='') as outfile:
        csv_writer = csv.writer(outfile, quotechar='"', quoting=csv.QUOTE_MINIMAL)
        csv_writer.writerow(["Tickers", "Market Cap", "EV", "Cash", "EV/Cash", "Drug", "Indication", "Event", "Date"])
        for result in results:
            csv_writer.writerow([
                result[0], 
                result[1], 
                result[2], 
                result[3], 
                result[4], 
                result[5][0].get("drug_name", ""), 
                result[5][0].get("indication", ""), 
                result[5][0].get("catalyst_event", ""), 
                result[5][0].get("catalyst_date", "")
            ])

    # ==== OLD ===
    # headers = ["Tickers", "Market Cap", "EV", "Cash", "EV/Cash", "Num Catalysts"]
    # print(tabulate(results, headers=headers, tablefmt="pretty"))

We use python's built-in csv module again to write our data to a csv file. We add the stock data and then the first Big Mover Catalyst event for each ticker if they have one.

If you run the program you should see a new file "catalyst_data.csv". Open it in Excel and you should see all the data! Final GitHub Repo.

Build a Stock Screener with Python (Part 2): Adding Catalyst Data

Fri, 11 Jul 2025 23:27:00 GMT

We will walk through how to pull biotech catalyst data (using Python and BPIQ) into a stock screener with other fundamental data about specific tickers you are interested in.

If you're interested in biotech investing and coding - let's go!

Here is the final screener:

+---------+------------+---------+---------+---------+---------------+
| Tickers | Market Cap |   EV    |  Cash   | EV/Cash | Num Catalysts |
+---------+------------+---------+---------+---------+---------------+
|  PRAX   |   $1.0B    | $529.6M | $328.0M |  1.61   |       2       |
|  ATXS   |  $359.5M   | $107.8M | $295.1M |  0.37   |       2       |
|  ATAI   |  $555.8M   | $369.7M | $98.2M  |  3.76   |       3       |
|  RCUS   |  $987.9M   | -$54.1M | $997.0M |  -0.05  |       2       |
|  HRMY   |   $2.0B    |  $1.5B  | $507.0M |  2.93   |       2       |
|  VKTX   |   $3.5B    |  $2.1B  | $851.9M |  2.49   |       0       |
|  MRUS   |   $4.1B    |  $3.2B  | $458.3M |  6.96   |       0       |
|  DAWN   |  $688.2M   | $188.8M | $473.0M |  0.40   |       0       |
|  REPL   |  $845.6M   | $308.5M | $483.8M |  0.64   |       1       |
|  ASND   |   $10.6B   | $10.7B  | $517.9M |  20.76  |       3       |
|  PHVS   |   $1.4B    | $723.3M | $236.5M |  3.06   |       1       |
+---------+------------+---------+---------+---------+---------------+

In Part 1 we walked through how to create a basic screener in python in ~10 minutes. We will use that as our starting base and build upon that. You can find the starting code in this GitHub repo.

In Part 2 (this one), we will pull biotech catalysts and merge them into our output table screener that we built in Part 1. In this example we will display how many catalysts each ticker has in the next 90 days.

You can see the final code for this Part 2 on GitHub here.

Before we begin remember to create/activate your virtual environment and install any packages from Part 1. If you are pulling the code for Part 1 from GitHub, you can install the python packages from Part 1 by running:

>>> pip install -r requirements.txt

We are going to make 2 upgrades:

Add a new function get_catalyst_data that will accept a ticker and call the BPIQ API to fetch the catalysts.
Update our main function to call the new get_catalyst_data function and handle adding that to our table output.

Add New Function get_catalyst_data

Before we create the new function we need to install a few additional packages and update our imports at the top of our script.

Start by installing requests, which we will use to call the BPIQ API:

>>> pip install requests

Now let's update the imports at the top of our script to include requests. We will also import a standard (built-in) python library called datetime.

from datetime import date, timedelta # NEW
import requests # NEW
import yfinance as yf
from tabulate import tabulate

We have the previous imports of yfinance and tabulate, but added datetime and requests.

Next create the function get_catalyst_data that:

Accepts a parameter ticker.
Sets how far ahead we want to limit catalyst dates.
Calls the BPIQ API and handles the API response.
Returns either a dash string or the number of catalysts in that date range.

def get_catalyst_data(ticker):
    today = date.today()
    months_to_add = 3
    future_date = today + timedelta(days=months_to_add*30)

    # call to bpiq api
    url = f'https://api.bpiq.com/api/v1/drugs/?ticker={ticker}&catalyst_date_max={future_date}'
    headers = {
        'Authorization': f'Token {credentials.BPIQ_API_KEY}'
    }

    response = requests.get(url, headers=headers)

    if response.status_code == 200:
        data = response.json()
    else:
        print(f"Request failed with status code {response.status_code}")
        return "-"
    
    return data.get("count", "-")

        # return the drug/catalyst data

You might have noticed we have "{credentials.BPIQ_API_KEY}". To make the call to the BPIQ API we need an API Key. You can get a free trial API Key from BPIQ. Once you get your key you can replace the code "{credentials.BPIQ_API_KEY}" with your API key "YOUR-API-KEY".

If you want to follow using the "{credentials.BPIQ_API_KEY}" method then:

Create a new file "credentials.py" and put your API Key in it like so:

BPIQ_API_KEY = "YOUR-API-KEY"

Import credentials at the top of your main python script.

from datetime import date, timedelta 
import credentials # <== NEW

import requests 
import yfinance as yf
from tabulate import tabulate

And with that we are finished with our function to get catalysts!

Now let's update our main function to call our new function and handle the output

You can see below we add 2 new lines of code and update 2 previous lines of code.

def main():
    with open("tickers.txt") as f:
        tickers = [line.strip().upper() for line in f if line.strip()]

    results = []
    for ticker in tickers:
        data = get_stock_data(ticker)
        catalyst_data = get_catalyst_data(ticker) # <== NEW
        results.append([
            data["Ticker"],
            format_number(data["Market Cap"]),
            format_number(data["EV"]),
            format_number(data["Cash"]),
            f"{data['EV/Cash']:.2f}" if data["EV/Cash"] else "-", # <== UPDATED
            catalyst_data # <== NEW
        ])

    headers = ["Tickers", "Market Cap", "EV", "Cash", "EV/Cash", "Num Catalysts"] # <== UPDATED
    print(tabulate(results, headers=headers, tablefmt="pretty"))

Now let's run our script and see our Updated Screener:

>>> python script.py

... It may run for a few seconds but be patient... 🎉

You can use this to check EV/Cash against how many near-term catalysts companies have, or modify the data to find different opportunities!

Want to pull this data into Excel? Check out Part 3 and do just that!

Build a Stock Screener with Python (Part 1): Initial Stock Screener

Tue, 08 Jul 2025 11:58:00 GMT

If you are interested in investing and/or coding, this post will teach you how to create a basic stock screener in under 10 minutes using python.

The python script will pull tickers we put into a .txt file and fetch the market cap, EV, and cash. We will display this in a table format so we can quickly screen the metrics.

You can find the full code in the repo

The final output will look like this:

+---------+------------+----------+---------+---------+
| Tickers | Market Cap |    EV    |  Cash   | EV/Cash |
+---------+------------+----------+---------+---------+
|  PRAX   |  $950.8M   | $529.6M  | $328.0M |  1.61   |
|  ATXS   |  $349.9M   | $107.8M  | $295.1M |  0.37   |
|  ATAI   |  $583.4M   | $369.7M  | $98.2M  |  3.76   |
|  RCUS   |  $870.4M   | -$54.1M  | $997.0M |  -0.05  |
|  HRMY   |   $1.9B    |  $1.5B   | $507.0M |  2.93   |
|  AAPL   |  $3135.8B  | $3114.1B | $48.5B  |  64.21  |
|  TLSA   |  $178.8M   | $172.5M  |  $3.7M  |  46.32  |
|  NFLX   |  $548.8B   | $579.1B  |  $8.4B  |  69.18  |
|  GOOG   |  $2149.5B  | $2085.8B | $95.3B  |  21.88  |
+---------+------------+----------+---------+---------+

Let's get started!

The first thing you want to do is confirm you have python installed on your machine or download and install it.
Once downloaded, via your folder system or terminal, navigate to the location you want to build this project and create a new file: "script.py".

Before we start coding we need to create a virtual environment and install a few python packages. Virtual environments allow us to install python packages in a standalone 'environment' so we can use them for specific projects.

In your terminal create and activate a virtual environment named 'env':

>>> python -m venv env
>>> .\env\Scripts\activate
>>> (env)

you should see (env) appear in your terminal after it's activated.

In your terminal with the active environment, let's install two packages we need for this project, yfinance & tabulate:

>>> pip install yfinance tabulate

Now let's code 💻🖥️

Our python script will consist of 3 functions:

a. get_stock_data() - will accept a ticker and get the data from Yahoo Finance.

b. format_number() - will handle formatting the number values to look better (e.g., $1M, $1B).

c. main() - will read in the tickers we put into a .txt file and orchestrate the output.
At the top of the script file, let's import the modules we installed.

import yfinance as yf
from tabulate import tabulate

Now let's create the get_stock_data function that will fetch the stock data for a ticker we pass in from yahoo finance.

def get_stock_data(ticker):
    stock = yf.Ticker(ticker)
    
    try:
        info = stock.get_info()
        market_cap = info.get("marketCap", None)
        enterprise_value = info.get("enterpriseValue", None)
        total_cash = info.get("totalCash", None)


        ev_cash_ratio = (enterprise_value / total_cash) if enterprise_value and total_cash else None

    except Exception as e:
        print(f"Error fetching data for {ticker}: {e}")
        return None


    return {
        "Ticker": ticker,
        "Market Cap": market_cap,
        "EV": enterprise_value,
        "Cash": total_cash,
        "EV/Cash": ev_cash_ratio,
    }

This function accepts a ticker, and uses the yfinance package to fetch the data about that ticker from yahoo finance. We return a dictionary with the fetched data.

Next let's build our format_num function that will format the data values we fetched above to look 'prettier'.

def format_number(num):
    if num is None:
        return "-"
    
    is_neg = num < 0
    num = abs(num)

    if num > 1e9:
        formatted = f"${num/1e9:.1f}B"
    elif num > 1e6:
        formatted = f"${num/1e6:.1f}M"
    else:
        formatted = f"${num:,.0f}"

    return f"-{formatted}" if is_neg else formatted

We accept a number to be passed in, check if it's a positive or neg number, and then format for million/billions and decimals. We return the formatted number checking if it's a positive/negative number.

Let's create our main function that will call our helper functions above and display the final table.

def main():
    with open("tickers.txt") as f:
        tickers = [line.strip().upper() for line in f if line.strip()]

    results = []
    for ticker in tickers:
        data = get_stock_data(ticker)
        results.append([
            data["Ticker"],
            format_number(data["Market Cap"]),
            format_number(data["EV"]),
            format_number(data["Cash"]),
            f"{data['EV/Cash']:.2f}" if data["EV/Cash"] else "-",
        ])

    headers = ["Tickers", "Market Cap", "EV", "Cash", "EV/Cash"]
    print(tabulate(results, headers=headers, tablefmt="pretty"))

We start by reading in tickers from a file 'tickers.txt', calling our get_stock_data function for each ticker, and then displaying our results using the tabulate package.

Before we run our script we need to create a 'tickers.txt' file and add 2 final lines of code to our 'script.py' file.
In the same directory/folder as your 'scripts.py' file create another file 'tickers.txt' and add a ticker you want to screen to each line (and save the file).

PRAX
ATXS
ATAI
RCUS

The last 2 lines of code our script needs is to call our main() function when we run our script. We can do that by checking if the name of the module is main() (which happens when we run our script directly).

if __name__ == "__main__":
    main()

Now run the script!

>>> python script.py

You should see the table output with the information for the tickers you put in your .txt file 🎉 Next up is Part 2 where we pull in catalyst data...

+---------+------------+----------+---------+---------+
| Tickers | Market Cap |    EV    |  Cash   | EV/Cash |
+---------+------------+----------+---------+---------+
|  PRAX   |  $950.8M   | $529.6M  | $328.0M |  1.61   |
|  ATXS   |  $349.9M   | $107.8M  | $295.1M |  0.37   |
|  ATAI   |  $583.4M   | $369.7M  | $98.2M  |  3.76   |
|  RCUS   |  $870.4M   | -$54.1M  | $997.0M |  -0.05  |
|  HRMY   |   $1.9B    |  $1.5B   | $507.0M |  2.93   |
|  AAPL   |  $3135.8B  | $3114.1B | $48.5B  |  64.21  |
|  TLSA   |  $178.8M   | $172.5M  |  $3.7M  |  46.32  |
|  NFLX   |  $548.8B   | $579.1B  |  $8.4B  |  69.18  |
|  GOOG   |  $2149.5B  | $2085.8B | $95.3B  |  21.88  |
+---------+------------+----------+---------+---------+

I Joined Coding Dojo: Mid Point Review

Mon, 06 Jul 2020 19:22:00 GMT

At this point I’ve spent over 120 hours within the code bootcamp. I’m at week 8 of 15.

If you haven’t already read my initial thoughts as to why I chose Coding Dojo over other bootcamps, you can check that out here

I’ve a couple people reach out to me via my twitter DM’s to ask about the bootcamp after reading my initial post, so I will include answers to their questions. I’m sure you may have similar questions if you are thinking about a bootcamp.

The first questions were regarding the content.

Since it’s an online course, everything is handled via the Coding Dojo learning portal:

The portal is where all the learning is done:

The learning modules which are video/text combos
The assignments which build off the learning modules
The live lecture recordings

The live lectures happen twice weekly and are held via zoom for 1 hour each. In them the instructor goes over the current topic usually by completing one of the assignments. They are useful because the instructor explains things and you can ask questions.

There is also a live chat similar to slack or discord. Within there you can interact with fellow students and instructors. You can also schedule 1-on-1 meetings with instructors to go over any problems.

Many people (possibly even you) may be looking at a bootcamp as a way to make a career change. I took this bootcamp after going down a CS college degree, but working in a different industry after graduating. So all the concepts are not brand new, I’m using it as more a spring board.

However if you are looking at bootcamps as a career change Coding Dojo does have a career services rep that helps you along the way. I haven’t personally used them so I can’t speak from experience.

The career rep contacted us early on regarding setting up our LinkedIn profiles, pushing code to GitHub, and starting to prepare a resume. They stressed that the biggest thing companies are looking for is a portfolio of projects.

The last 4 weeks of the course are dedicated to solo and group projects.

My personal thoughts so far

After 8 weeks of spending 20–25 hours coding specifically related to Coding Dojo material (and probably more on self-learning as well) I can say that this is A LOT of material.

Each week or two we cruise through a new major topic or tech. HTML, CSS, JS, Python, Django. Thankfully I was familiar with most of them (barre Django). You could easily spend 4x the amount of time on each concept and still have room to learn more.

However, the chronological order paired with the instructors teaching style helps the concepts make sense. They understand what you know/don’t know since they taught you. So they don’t assume you understand certain tech. And most of the content is pre-recorded so it’s consistent.

Just like most things, repetitions are a huge factor in committing to memory.

And so it comes down to putting your fingers on the keyboard, and coding. The nice thing is they give you the opportunity to code a bunch.

Each topic sort of goes like this:

Learn something [topic A]
Practice [topic A]
Learn something [topic B]
Practice [topic A and topic B]
So on..

You can see from above you get a lot of practice with the various topics. I really like this approach to teaching.

So far I am happy with the Coding Dojo experience and recommend it. I will be back in 4 weeks after completing the final projects, with my final thoughts.

Until then you can follow along on my day-to-day coding and what’s it’s like inside via my Twitter: https://twitter.com/DomVacchiano

I Developed a Product at 18: Post-Mortem Review

Sat, 25 Apr 2020 17:06:00 GMT

It’s late May 2014, the school semester was just about to end and I had summer break on my mind. Was I going to get a job somewhere and earn some extra cash? Was there going to be a lot of parties?! (jk 😉 I wasn’t 21 yet).

Actually, I was only 18 years old and was about to head home for the summer after finishing my freshman year at the University of Iowa. My parents lived outside Chicago so it was about a 3 hour drive back, nothing crazy.

Remember how I was thinking about getting a job [parties]? Well during previous summer breaks I helped my dad with one of his side-project companies, usually entering data into a database. But this summer all my friends were either trying to get an internship or more commonly a job at a local store.

I thought that might be a good idea, I could make some money and get some experience on my resume. But my dad had a better idea (parents usually have better ideas).

His idea was to launch a product filling a need he had, keeping all those darn squirrels off his bird feeders.

My summer job basically was that I worked for him, doing all the work myself under his guidance. It was almost like I was VC backed… 😂

That summer I learned more than I have in my entire life.

Ok maybe that’s a bit of a marketing exaggeration but I did learn a great deal about marketing, product development, packaging and logistics, web development, finances, selling on Amazon, the list is almost endless.

We laid out the schedule for the summer and each week I gave a presentation with the prior weeks accomplishments and deliverables. The general outline went something like this:

I only had about 3 months to do all this so I got started ASAP and had to work quickly. The good news was that I was a eager and excited. This was the best summer job ever. The bad news was I had no experience doing any of this..

Biz Plan & Competitive Analysis:

The very first thing I did was look at what competitive products were out there. If something already fit the need very well the whole entire thing could be a bust. After Googling a bit and looking on various marketplaces I didn’t find too much. Now that either meant that:

Nobody thought of this idea and it’s an untapped market (not likely)
The market is too small and people don’t think there’s enough money to be made (more likely)

At the time I didn’t know any better, I thought everybody was an idiot and our product would have barely any competition. I also put together a business plan which contained some financial and market research to try and gauge how big the market was.

One thing I did find was that the bird feeder industry is quite large and bird feeders are very common. I also looked at the prevalence of squirrels and those flying rats are everywhere.

After this, the project was green lighted to continue onto the next phase (Stage-Gate model anyone?). At this point Squirrel Grease was born!

_{rough logo, I know}

Next Onto Research & Development

My dad comes from a science/PhD background and R&D is very large in that field. He wanted this product developed in a very scientific way. So what did I do?

I ran a science experiment. R&D was broken down into 2 phases basically:

Research possible product candidates/formulations
Test them against each other as well as a control

I researched all sorts of stuff about squirrels and other mammals and what may deter them and what are the most slippery substances. I landed on a few different ideas that I wanted to test: (had a lot more that I tried)

Petroleum Jelly + Hot Sauce
Petroleum Jelly + Cinnamon
Oil + Hot Sauce
Oil + Cinnamon

I know I know, very complicated ingredients, cut me some slack though this was all new to me. I did spend a lot of time trying all sorts of hot sauces, oils, cinnamon, and preparing them in various ways like with heat.

Next I set out to create the science experiments and see which formula worked best. I went to my local hardware/outdoor store, bought 4 bird feeder poles and spread them out across the backyard. I kept the far left one as control (no formulation) and applied a different product candidate to the others, then sat by the window…

I sat there with my laptop and took notes of what I observed. After a couple days or weeks (I wish I had that laptop still to find this data) I decided that the product candidate to move forward with was… *drum roll please* Petroleum Jelly + Cinnamon.

I manufactured it in the kitchen by heating up petroleum jelly on the stove, adding in cinnamon, letting it cook, and then straining out the cinnamon.

Here is a short clip I found from Instagram of me making it back in the day.

After successfully finding something that worked better than control, based on my expert scientific knowledge (lol) we had yet again passed another checkpoint (Stage-Gate model). It was time to move onto packaging and labeling.

Bottling this thing up

I had no idea where to begin at this phase. After a lot of Googling, I found out these various containers have specific names, I didn’t know what size to go with, what type of seal I needed, or even what type of lid. What I ended up doing was finding a company who made all sorts of containers and got a whole heap of samples to try out.

From there I went with what I thought made sense based on one thing — what size I was getting the petroleum jelly. I was buying the petroleum jelly in bulk and wanted to be able to fill all the containers without wasting any. I think I settled on 8 oz. or 12 oz. containers.

The labeling was another painful point for me. I wasn’t very aesthetically gifted when it came to design and I also had never printed labels before. I went to my local home office store (or probably Amazon) and bought a pack of printable Avery labels. I set out to design the label and after a lot of wasted paper (sorry trees) I landed on this beauty of a design:

The packaging and labeling portion bleeds into the marketing efforts so I also did things like look at competitors reviews to see what their customers were saying. One common theme was that the products washed away with rain, so I saw from our ‘test’ results that Squirrel Grease worked even after rainy days. I wanted to leverage this by including ‘Weather Resistant!” on the label.

Was I the marketing genius of my time? A whopping no, but at least I tried!

Marketing & Digital Presence

So far we had:

laid out a business plan
Developed the product
Packaged and labeled her up

Now it was time to create the digital sales and marketing channels. Throughout high school I was interested a bit in coding and played around with html/css but nothing very serious. I knew one of the channels I wanted online was a website. I had no idea about payment processing but thought Amazon was a large marketplace and could help handle processing, inventory, invoices, etc. I also thought pursuing some social media marketing would be useful, probably because it’s what I was using personally. I didn’t know about paid ads but that would have been a good route to pursue.

Out of interest I set out to build a website for Squirrel Grease, looking back I should have used an easier solution that could have handled the features I needed:

Static info pages about the product
Contact/Email form
Ordering and payment processing

It’s a pretty simple website and if I did it today I would go with Shopify. However being young and dumb (recurring theme? 😂) I built this website below. It’s taken down now but here it was in all it’s glory:

I set up Facebook, Instagram, YouTube, and Twitter accounts. I also listed the product on Amazon. I remember running into some trouble with Amazon, I needed the UPC number (Universal Product Code), the barcode and related EAN number in order to list and sell on Amazon. I can’t remember exactly but I had to go back and register this and add it to the label. After all that I listed it up on Amazon:

I didn’t set up a payment portal via the website because I didn’t know how so I just linked to the Amazon page. I think I sold about 10–15 of these over the course of a year or so. And you can see the whopping 3.5 star review. Still not sure if the 5 stars were just family members but I’ll take it.

I also put together this illustrative promo video:

Post-Mortem Review

Sadly after returning to college I had to lay Squirrel Grease to rest. I kept making it for a little while mostly for my dad, and a few relatives who still use it to this day. Some day I may revive Squirrel Grease and give it a much needed face lift.

Some of the biggest takeaways:

Developing a product is wayyy more than just the product itself, you need to have some flavor for marketing, finances, business, design, etc.
Easier is better — don’t do something just to do it. Make a list of what you need and pick the choice that accomplishes that with the lowest amount of friction.
Stage-gating is a powerful tool. Check yourself and your idea/product/business to ensure the path still makes sense. Time is a valuable resource and this helps to conserve that.

Thanks for reading, if you enjoyed this check me out on Twitter @domvacchiano. I Tweet about business, investing, and coding. If you have any questions feel free to shoot me a tweet or message.

Since launching Squirrel Grease I have done a lot things, from working at an eCommerce company customizing Shopify stores, to investing in biotech companies with a fund. Who knows what the future has in store..

—

This was an old post I published on Medium in 2020 - ported over to this blog in 2025

I Joined Coding Dojo: Decision Process and Pre-Camp Thoughts

Sun, 12 Apr 2020 19:22:00 GMT

I recently registered for a Python full stack web dev bootcamp through Coding Dojo that runs 4 months (16 weeks) and is estimated to require 20 hours per week. The cohort starts May 4th 2020. I am going to be documenting my journey throughout the bootcamp to give insight into my experience. I know before I enrolled I was skeptical about whether it was worth the price. I created a table with various online bootcamps and some basic info you can check out below:

update: I posted a mid-point review after 120+ hours

FT = ‘full time’, PT = ‘part time’, FS = ‘full stack’

I ended up choosing Coding Dojo for a couple reasons:

I did my undergrad (like 4 years ago) in informatics and we used Python — so wanted to stick with that language
I am taking the summer semester off from my grad program — so wanted something that fit that timeline
Wanted a decent deal ($$), feel like a lot of these bootcamps are pricey and was skeptical of the actual value (hint hint: GA)

So I signed up and filled out the initial questionnaire asking things like my experience and how many hours per week I planned to dedicate to the program. After I submitted that info I was sent an email with instructions on how to reserve my seat — which essentially means pay up, they give you $250 off if you do this within 5 days (nice marketing technique here)

I went ahead and signed up for the May 4th cohort, which fit nicely with my graduate program whose semester ends around the end of April. This gives me some time to run through the pre-bootcamp stuff which actually is a decent amount of reading/assignments. I’m glad Coding Dojo does this instead of just throwing us in the first week, this is a nice way to re-touch up on the basics and get acquainted with the Coding Dojo ‘Student Portal’, or whatever you wanna call it.

The Student Portal is where you access all the course content, it’s a personalized profile which also houses ‘Belts’ you earn. I’ll explain this Belt system in more detail later on.

I just signed up last week so I had a couple days to learn the system a bit and overall I like it. They lay everything out chronologically and estimate how long things are going to take so you can plan better. So far there was reading and an assignment which went over programming basics with JavaScript as the language. They said that the pre-bootcamp work takes about 30 hours so i’m trying to spread it out across the next 3 weeks before my cohort officially starts.

update: I posted a mid-point review after 120+ hours

if you have any specific questions about the bootcamp or have some insight to share shoot me a tweet @DomVacchiano.

I initially posted this on April 12, 2020 on Medium and my previous blog.