Forem: Kaavian Sivam

A Guide To Launch Your Dev Tool on Hacker News — Track Where Your Conversions Came From

Kaavian Sivam — Sat, 25 Nov 2023 15:34:49 +0000

A Guide To Launch Your Dev Tool on Hacker News — Track Where Your Conversions Came From

Hacker News (HN) is a popular news website for developers, techies, and startups. It has become a go-to resource for those looking for the latest news and updates in the tech industry. HN is similar to Product Hunt in that it works based on upvotes — the more upvotes a post gets, the higher it will appear on the site. This means that the content on HN is curated by its users and mods. The most popular posts are the ones that get the most attention.

If you are a developer or a startup looking to launch your product, HN can be a great platform to showcase your work. In this blog post, we will discuss the differences between launching on Product Hunt (PH) and HN and provide some tips on launching your dev tool on HN.

Product Hunt Vs. Hacker News

While launching a product, people often end up with just the Product Hunt. While Product Hunt is a platform focused on product discovery, HN focuses more on news and discussion. PH is filled with tech founders, product folks, and entrepreneurs, while HN is loaded with software professionals, IT guys, and tech enthusiasts. PH engagement is often around the utility and features, while HN is around tech details, functionalities, and features.

In summary, launching on PH may be more beneficial if your product is focused on discovery and utility, while launching on HN may be more beneficial if your product is focused on tech details and functionalities.

We have written a similar blog on launching your dev tool on Product Hunt.

Why is Hacker News Crucial for Dev Tools?

I asked KrunchGPT, a custom GPT built for Dev Marketers or DevRels, why dev tools should launch in HN. It said this:

Targeted Audience : HN is a hub for developers, tech enthusiasts, and industry experts, making it an ideal platform to reach potential users who understand and value developer tools.
Valuable Feedback : The HN community is known for providing insightful and constructive feedback, which can be crucial for refining and improving your tools.
Brand Visibility : Regular engagement on HN increases brand awareness and visibility within the tech community, enhancing your product’s reputation and recognition.
Network Building : HN offers opportunities to connect with industry professionals, potential collaborators, and investors, opening doors for partnerships and growth.
Market Validation and User Acquisition : Positive reception on HN can serve as market validation for your tool and drive significant traffic to your website, aiding in user acquisition.

To give you some examples of how some dev tools leveraged to get more eyes on their product, Groove received 105,000 visits from HN one month before launching their last version. They got 97 signups and 14 paying customers.

How do you launch your dev tool on HN?

If you have decided to launch your dev tool on HN, there is a set of instructions that HN itself provides. I’m sharing a few more tips to help you make the most out of the opportunity:

Create a Proper Story

One of the keys to success on HN is creating a proper story. You need to speak the audience’s language and state the problem statement you’re solving clearly. Tell your story and why you picked this problem to solve. Make sure that your story is compelling and interesting and that it resonates with the HN audience.

Make Your Landing Page More Understandable

Your landing page is the first thing people will see when they click on your HN post. This means that it needs to be clear, concise, and easy to understand. Use visuals and graphics to help explain your product and its features. Make sure that your landing page is optimized for mobile devices and that it loads quickly.

Let’s take these Example 1 & Example 2 threads, and you can see how important having the right messaging on the landing page is.

Set Up a Proper Pricing Page

If you are selling a product, you need to make sure that you have a proper pricing page. This should clearly state the price of your product, any discounts or promotions you are offering, and any other relevant information. Make sure that your pricing page is easy to navigate and that it is optimized for conversions.

Check Whether All Things Are Working in Your Product

Before launching your dev tool on HN, you must ensure everything is working properly. Test your product thoroughly and check whether all its features work as intended. Make sure that there are no bugs or glitches that could cause problems for users.

Use Repo Instead of Landing Pages

One of the best ways to showcase your product on HN is to use your repository instead of a landing page. Given that most HN users are techies, redirecting them to your GitHub repo can lead to stars and forks, which in turn increase your product’s visibility. Ensure that your README file is as good as your landing page and updated regularly.

Make a Direct Title Stating the Intent

Your title is one of the most important parts of your HN post. It needs to be direct and to the point and clearly state your post’s intent. Make sure that your title has “Show HN” or “Launch HN” in front of it. Don’t try to sell to the audience and definitely stay away from clickbait titles like “5 ways to solve X problem”, “How to solve X problem using our solution”. I suggest you to give it a read our previous blog on how to create content for developer communities.

Post Multiple Times

Posting your dev tool on HN multiple times can increase its visibility and reach. However, you need to be careful not to overdo it. Posting too often can be seen as spammy and may result in your posts being flagged or removed. A good rule of thumb is to post once every few weeks or when you have a major update or new feature to showcase.

Set Up Analytics to Track Your Visitors

Finally, you need to set up analytics to track your visitors. Use tools like Krunch to track the visitors from your HN traffic. This will help you see how many people visit your landing page and sign up for your product. Use this information to optimize your landing page and to improve your product.

Other Small Things You Need to Take Care of

In addition to the tips above, there are some other small things that you need to take care of when launching your dev tool on HN. These include:

Avoid Sharing Link: Don’t share the direct link of your posts and ask for upvotes. HN won’t consider the upvotes coming from direct links
Office Upvotes don’t count: HN considers one upvote per IP address. If your ask your employees who are all in the same IP upvote your post, you will just see one. Once you add your post, you can see that under Newest. Ask your friends from different IP to upvote.
Timing your launch: Weekends tend to have less competition but have good traffic. Weekdays during working hours are also good to go.
Engaging with your comments: Respond to comments on your post and engage with your audience to build a community around your product.
Leveraging your network to start the conversation: Use your social media channels and personal network to promote your HN post and drive traffic to your landing page.
Being mindful of how you talk: Make sure that you are respectful and professional in all of your interactions on HN. This will help you to build a positive reputation and to gain the trust of your audience.

Conclusion

In conclusion, launching your dev tool on HN can be a great way to showcase your work and reach a wider audience. By following the tips outlined in this post, you can increase your chances of success and make the most out of this opportunity. Remember to create a compelling story, make your landing page more understandable, set up a proper pricing page, check that all things are working in your product, use a repository instead of a landing page, make a direct title stating the intent, post multiple times, set up analytics to track your visitors and take care of other small things.

Originally published at https://krunchdata.io on November 25, 2023.

Ultimate Guide on Product Hunt Launch for Dev Tools

Kaavian Sivam — Sat, 25 Nov 2023 15:13:16 +0000

With the rising popularity of Product Hunt, it is becoming increasingly crucial for dev tools to have a well-executed launch that will garner the attention of developers worldwide. Your product’s visibility and reach depend heavily on the way you launch your product. Especially when planning your product release, it’s crucial to understand the nuances of launching a product in the Product Hunt.

In this article, we will discuss why Product Hunt is the perfect platform for dev tools, the benefits of launching on Product Hunt, and strategies for a successful dev tool launch.

So, let’s dive in and get started!

What is Product Hunt

Let’s start with the basics.

Product Hunt is not just a platform; it’s a bustling hub for product discovery with a spotlight on technology and developer tools. In this platform, there are three personas: Makers, the creative minds behind products; Hunters, the enthusiasts keen on discovering and sharing; and Marketers, the individuals propelling products into the limelight. Think of it as a digital marketplace where GitHub’s Atom soared to fame through a meticulously executed Product Hunt launch, capturing the attention of developers worldwide.

Why Launch Dev Apps on Product Hunt?

But why choose Product Hunt for your grand unveiling? The answer lies in its developer-inclusive exposure. While marketers play a crucial role, Product Hunt magnetically draws a massive developer audience. According to a recent discussion within the Product Hunt community, there are over 78% of its users are tech-savvy creators. This makes it the ideal platform for dev tools, as exemplified by the monumental engagement witnessed during VS Code’s Product Hunt launch, highlighting the platform’s inherently developer-friendly environment.

Benefits of Launching Dev Tools on Product Hunt

The primary advantage of launching on Product Hunt is the chance to connect with a highly targeted developer audience. Dev tools, when showcased here, reach a concentrated audience actively seeking innovative solutions. This ensures not only visibility but also opens the door to valuable developer feedback. Dev tools such as Robinhood, Houseparty, eero, etc, show us how a Product Hunt launch facilitated direct feedback loops, contributing significantly to product improvements.

Strategies for a Successful Dev Tool Launch on Product Hunt

I asked the KrunchGPT, a custom GPT that Krunch has built for developer marketers and DevRels, for tips on successfully launching dev tools on Product Hunt. This is what it said:

Understand Product Hunt : It’s crucial to understand that Product Hunt focuses on new tech or significantly revamped tech. Understanding the platform’s curation algorithm and community preferences is essential.
Build a Network on Product Hunt : Engage with the community and create a network. Upvotes and comments from high-value users can significantly impact your launch.
Engage with the Community : Active participation and responding to comments and feedback during the launch are crucial.
Prepare Marketing Assets : Develop compelling marketing materials and a landing page to support your launch.
Build Interest : Get people excited about your product before the launch. The first 24–48 hours are critical for traction.

Apart from these inputs, I would like to share a few more to you.

Create a Contact List

Launching on Product Hunt is not a solo act. It begins with creating a contact list and identifying key influencers and potential users within the developer community. As mentioned by KrunchGPT before, timing is critical, especially in the first four hours post-launch, with 12:00 AM PST identified as the optimal launch window. Redis Labs’ success story is a testament to the impact of personalized outreach to influential developers during their Product Hunt launch.

To get started, here are some of the communities we recommend you interact with: Product Hunt Upvoters, Startup Product Launches, Product Hunt Exchange communities, Product Hunt Europe, Product Hunt Upvote Promotion Exchange club, Product Hunters, Indie Hackers, Invincible Product Hunters, and Startup Growth Hacking.

Warm Up Your Product Hunt Account

Engaging with the Product Hunt community before the launch is akin to tuning your instrument before a performance. Establishing a genuine presence and active participation in dedicated dev tools communities significantly enhances visibility. GitLab, for instance, actively immersed itself in discussions, creating anticipation and laying the groundwork for successful dev tool launches.

Review and Warm Up Makers Account

The maker community is at the heart of Product Hunt, and actively participating in discussions among fellow makers is pivotal. Building authentic relationships within this community sets the stage for a more impactful launch. The team behind Atom, for example, engaged proactively in the Product Hunt community before launching new dev tools, establishing credibility and anticipation.

Crafting a Memorable Introduction

First impressions matter, especially in the visually-driven world of Product Hunt. Crafting a memorable introduction involves designing eye-catching visuals — be it a GIF or image for the dev tool’s logo. Visual appeal is more than aesthetics; it significantly influences the chance of getting upvoted. Visual Studio Code’s captivating logo and GIF, for instance, contributed significantly to its immediate success.

Competitor Analysis

In the sea of launches, standing out is imperative. Thorough competitor analysis is akin to navigating these waters skillfully. Checking for existing launches from competitors around the scheduled launch date and identifying opportunities to highlight unique features ensures differentiation. GitLab’s comprehensive competitor analysis, for instance, ensured that its launch stood out with distinctive features, setting it apart in a crowded landscape.

Avoid Blind Requests for Upvotes

Building organic relationships is a cornerstone of success on Product Hunt. Rather than blindly seeking upvotes, focus on providing value to discussions. Genuine engagement increases the likelihood of upvotes. It is important to hone in on building relationships and adding value, resulting in organic upvotes and a more authentic presence within the developer community.

Exclusive Discounted Pricing for Hunters

Incentivizing early adoption is a powerful strategy. Offering exclusive pricing for Product Hunt users creates a sense of exclusivity for the Hunter community, fostering loyalty and increasing conversions. According to a survey conducted by the Product Hunt Community, 100% of the users would like to be offered exclusive discounts, encouraging early adoption and solidifying their position within the developer community.

Preemptively Prepare FAQs

Anticipating and addressing potential questions is a proactive strategy to provide a seamless experience for users during the launch. Responding to FAQs within the first hour significantly increases satisfaction, contributing to a positive developer experience. Sentry’s founders actively addressed developer queries during their Product Hunt launch, showcasing a commitment to user satisfaction and engagement.

As we wrap up this comprehensive guide, it’s crucial to reiterate the key strategies for a successful dev tool launch on Product Hunt. The emphasis lies in the developer-centric nature of this community. From engaging influencers to crafting visually compelling introductions, every step is geared towards resonating with the tech-savvy audience that frequents Product Hunt.

Remember, the first four hours post-launch are pivotal, and timing is everything. The optimal launch time at 12 PM PST aligns with the active hours of the global developer community. Warming up your Product Hunt account, actively engaging with fellow makers, and crafting a memorable introduction set the stage for a compelling launch. Competitor analysis ensures you stand out, avoiding blind requests for upvotes while building authentic relationships within the developer community.

Product Hunt isn’t just a platform; it’s a thriving ecosystem where dev tools can thrive. Embrace the developer community, leverage their insights, and embark on a journey of continuous improvement.

Your success on Product Hunt is not just about launching a dev tool; it’s about becoming an integral part of a community that values innovation and collaboration. Here’s to your dev tool’s triumphant launch on Product Hunt!

Originally published at https://krunchdata.io on November 25, 2023.

How I built my first app using ChatGPT

Kaavian Sivam — Thu, 03 Aug 2023 19:25:56 +0000

Hey folks!
I wanted to share with you all about the Q&A app I built from scratch using ChatGPT with the sole purpose of learning how to build an app. But , before going further, I need to tell you my background a bit.

This month, I completed 5 years in content/growth marketing, and I have a Bachelor’s in Computer Science Engineering from one of the top 10 colleges in my state. It’s been almost 5.5 to 6 years since I last programmed anything. In fact, I’ve never actually developed anything during my college days. I wrote about my journey on how I joined Zoho as a content writer a few years back.

Enough of my background. Now, I’ll give you the context of this blog.

At Requestly, where I’m currently handling the Growth team, we decided to spend a day exploring AI and how it can influence our productivity. We were tasked to either build or find a good AI tool and had a “demo hour” where we showcased what we built/found.

Unsurprisingly, many of my colleagues found a lot of useful tools that can actually improve how we function at Requestly. A few tools I would like to mention here are writemyPRD, yoodli, and reword. I found these tools very interesting, and you all should give them a try.

Now, I had way too many ideas on my mind that I wasn’t sure which one I should explore. Then, I finally settled down with the idea of building a ChatGPT module within our blogs and products. While I was exploring ChatGPT, I found this plugin called LinkReader that helps ChatGPT to read all the content within a given URL.

( P.S. This plugin was not available by the time I published this article! One more reason for me to be glad that I built this tool )

I wanted to build a similar tool that can read the content we have already published and provide a summary of the questions asked with a link to the relevant page. As a guy who can’t actually build, I just turned to ChatGPT itself to build an in-house ChatGPT.

It’s all about prompts!

Initially, I didn’t even know where to start and couldn’t find heads or tails of it. I started with building a link scrapper, so I went to ChatGPT and asked it to build me the scrapper by itself. It gave me a code that I didn’t even know how to run it!!

I went back to the basics. I tried to learn what Python Flask is, how to install Python on my Mac and how to run Python scripts. Gathered some ideas, installed Python and ran the script.

Boom! ran into something that every developer treads.

I had to call in some Air Support to clear out the buggies. My Co-founders and colleagues: Sagar, Sahil, and Rohan, were kind enough to get on a huddle with me and found that the port I was trying to call was used by some other tool, and that’s why Localhost wasn’t loading. While exploring this, I learned methods for identifying which tools are utilizing specific ports. You can also learn it from here.

My objective was to build a tool that can answer questions based on the URL I’m giving. Again, I turned to ChatGPT, and it advised me to go with Python Flask. I stayed with Bootstrap as the front end because I had experience in building basic web pages earlier. I named the app Vina as it means question in Tamil.

Reading all the content in a given URL will require a combination of different libraries, such as requests to handle the HTTP requests and beautifulsoup4 or lxml to parse the HTML content. So let me walk you through the process of creating the Vina app.

Step 1: Fetch and Parse Web Content

You will first need to fetch and parse the web content. This is how the code will look like:

import requests
from bs4 import BeautifulSoup

def fetch_webpage(url):
    response = requests.get(url)
    return response.text
def parse_webpage(html_content):
    soup = BeautifulSoup(html_content, 'html.parser')
    return soup
def extract_content(soup):
    text = ' '.join(soup.stripped_strings)
    return text
def main(url):
    html_content = fetch_webpage(url)
    soup = parse_webpage(html_content)
    text = extract_content(soup)
    print(text)
if __name__ == ' __main__':
    main('<https://example.com>')

The fetch_webpage function takes a URL and returns the HTML content of that page as a string. The parse_webpage function takes HTML content and returns a BeautifulSoup object that you can use to navigate the HTML tree. The extract_content function takes a BeautifulSoup object and returns a string with all the text on the page. The main function ties everything together. It fetches the webpage, parses it, extracts the content, and then prints the content.

Step 2: Setup OpenAI GPT Model

Firstly, you’ll need to install the OpenAI python client.

pip install openai

Next, you’ll need to set up the API key. This key is usually provided when you sign up for OpenAI’s API service. You can set this up in your environment using:

import openai
openai.api_key = 'your-api-key'

Step 3: Process the User Question and Generate a Response

With the web content and user question, you can then call the API to generate a response. The idea here is to prepend the question with the content of the webpage, which will serve as the context for the model. Then, ask the model to generate a summary or answer based on this context.

def generate_answer(context, question):
    prompt = context + "\\n\\n" + question
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        temperature=0.5,
        max_tokens=150
    )
    return response.choices[0].text.strip()

In this function, context is the content of the webpage, and question is the user's question.

Step 4: Stitching all of them together

Now that we built a content parser and response generator, it’s time to stitch them together to get our Vina app.

import requests
from bs4 import BeautifulSoup
import openai

# Functions to Fetch and Parse Web Content
def fetch_webpage(url):
    response = requests.get(url)
    return response.text
def parse_webpage(html_content):
    soup = BeautifulSoup(html_content, 'html.parser')
    return soup
def extract_content(soup):
    text = ' '.join(soup.stripped_strings)
    return text
# Function to Generate Answer Using OpenAI GPT-3/GPT-4
def generate_answer(context, question):
    prompt = context + "\\n\\n" + question
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        temperature=0.5,
        max_tokens=150
    )
    return response.choices[0].text.strip()
# Main Function
def main(url, question):
    # Fetch and parse web content
    html_content = fetch_webpage(url)
    soup = parse_webpage(html_content)
    context = extract_content(soup)

    # Set OpenAI API Key
    openai.api_key = 'your-api-key' # Replace with your actual OpenAI API key
    # Generate and print the answer
    answer = generate_answer(context, question)
    print(answer)
# Execution
if __name__ == ' __main__':
    url = input("Enter a URL: ")
    question = input("Enter your question: ")
    main(url, question)

However, I faced 2 major problems. When I ran this code, I came across this error:

InvalidRequestError: This model's maximum context length is 4097 tokens, however you requested 4694 tokens (4544 in your prompt; 150 for the completion). Please reduce your prompt; or completion length.

It means the limit on the maximum number of tokens that the OpenAI API can process in one request is 4097, but my request is 4694 tokens. I had to truncate the request and limit it.

def extract_content(soup):
    text = ' '.join(soup.stripped_strings)
    # Truncate text to fit within token limits
    truncated_text = text[:4096]
    return truncated_text

The second major issue I faced was that the code ChatGPT gave was just returning the question I asked instead of providing an answer for it. It was appending the question at the end of the context, which can lead to such situations where the answer is not as expected.

So, I went back to ChatGPT and shared the error, and it rectified the mistake by modifying the generate_answer function like this:

def generate_answer(context, question):
    prompt = f"{context}\\n\\n{question}\\nAnswer:"
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        temperature=0.5,
        max_tokens=150
    )
    return response.choices[0].text.strip()

It just changed the format of my prompts to a Q&A format so that the code can process the question and answer it. Once I updated the code, Vina was able to give me answers to the questions I was asking.

Now, I asked ChatGPT to modify the existing code to answer multiple questions for the given URL, and it changed the code like this:

from flask import Flask, request, render_template, redirect, url_for, session
import requests
from bs4 import BeautifulSoup
import openai

app = Flask( __name__ )
app.secret_key = 'your_secret_key' # Replace with your secret key
# Functions to Fetch and Parse Web Content
def fetch_webpage(url):
    response = requests.get(url)
    return response.text
def parse_webpage(html_content):
    soup = BeautifulSoup(html_content, 'html.parser')
    return soup
def extract_content(soup):
    text = ' '.join(soup.stripped_strings)
    truncated_text = text[:3946] # Truncate text to fit within token limits
    return truncated_text
# Function to Generate Answer Using OpenAI GPT-3/GPT-4
def generate_answer(context, question):
    prompt = f"{context}\\n\\n{question}\\nAnswer:"
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        temperature=0.5,
        max_tokens=150
    )
    return response.choices[0].text.strip()
@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        url = request.form.get('url')
        # Fetch and parse web content
        html_content = fetch_webpage(url)
        soup = parse_webpage(html_content)
        context = extract_content(soup)
        session['context'] = context
        return redirect(url_for('ask'))
    return render_template('index.html')
@app.route('/ask', methods=['GET', 'POST'])
def ask():
    if 'context' not in session:
        return redirect(url_for('index'))
    if 'answer' in session:
        answer = session['answer']
        session.pop('answer', None)
    else:
        answer = None
    if request.method == 'POST':
        question = request.form.get('question')
        # Set OpenAI API Key
        openai.api_key = 'your-api-key' # Replace with your actual OpenAI API key
        # Generate answer
        answer = generate_answer(session['context'], question)
        session['answer'] = answer
        return redirect(url_for('ask'))
    return render_template('ask.html', answer=answer)
if __name__ == ' __main__':
    app.run(port=5000, debug=True)

Now all I have to do it to build a front for this code where I can share a URL and ask questions from the URL. So, this is the webpage I created for the Vina tool. I needed two pages- an ‘index’ page where I’ll be feeding the URL and an ‘ask’ page where I’ll be asking my questions and getting my answers.

<!-- index.html -->

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Web Content QA</title>
    <link href="<https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css>" rel="stylesheet">
</head>
<body class="bg-light">
    <div class="container py-5">
        <h1 class="mb-4">Enter URL</h1>
        <form method="POST" action="/">
            <div class="mb-3">
                <input type="url" id="url" name="url" class="form-control" placeholder="<https://example.com>" required>
            </div>
            <button type="submit" class="btn btn-primary">Submit</button>
        </form>
    </div>
</body>
</html>

<!-- ask.html -->

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Web Content QA</title>
    <link href="<https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css>" rel="stylesheet">
</head>
<body class="bg-light">
    <div class="container py-5">
        <h1 class="mb-4">Ask a Question</h1>
        <form method="POST" action="/ask">
            <div class="mb-3">
                <label for="question" class="form-label">Enter Question:</label>
                <input type="text" id="question" name="question" class="form-control" required>
            </div>
            <button type="submit" class="btn btn-primary">Ask</button>
        </form>
        {% if answer %}
        <div class="mt-5">
            <h2>Answer:</h2>
            <p>{{ answer }}</p>
        </div>
        {% endif %}
    </div>
</body>
</html>

Finally, after spending close to 4 hours, this is what the Vina app looks like:

P.S. This blog was NOT written using ChatGPT 😜