How I restarted my build journey

I have been building products and startups for more than 5 years now. For the last 3 years, I've been deep into Veertly and Gomada. But this July, after closing Gomada, I decided to go back to build mode. This time, I'm aiming to build smaller products in public. In this blog post, I share how I restarted my build journey by building Quick Actions, a plugin for Crisp.

I also started getting more active on X and reading more about how other builders find inspiration and do their work. We see daily issues in the tools and processes we use, but unless our minds are open to new ideas, we won't remember them when it's time to build again. That's what happened to me. I spent 3 years growing Veertly without thinking about what comes next. When I wanted to get back to building, I was out of great ideas.

Getting inspiration

Reading this quote on Julien’s blog post about his journey to becoming a bootstrapper was a lightbulb moment for me. Instead of guessing what might work, I needed to look back at my past experiences and connect the dots.

I spent a few days recalling my time as a founder and CTO at Veertly. I created a mind map of problems and ideas that came to me during this reflection. Some interesting stuff popped up, but nothing that got me super excited.

While exploring Julien's work, a Twitter thread on building a SaaS in 48 hours caught my eye. He emphasized the value of leveraging existing platforms. As a regular Crisp user, I immediately started thinking about optimizing its functionality for support tasks.

I was impressed by Julien's Quick Links plugin, which allows operators to swiftly navigate to external platforms directly from the Crisp interface. For example, it can use chat metadata to open a Stripe dashboard tailored to the user you're chatting with.

This made me revisit my experiences at Veertly and sparked an idea: Why not develop a Crisp plugin that lets operators call APIs directly? Instead of just linking to other platforms, such a plugin could trigger workflows or perform specific tasks. At Veertly, we use Crisp extensively but haven't tapped into its full potential by integrating it with other tools. I saw an opportunity for a highly useful plugin and decided to build it.

This decision aligns with Daniel Vassallo's insights from his Small Bets course. He advocates for being open to randomness and making room for unexpected opportunities, what he refers to as the "Stochastic World". You should create mechanisms in your life to let serendipity in. Some examples are: reading books, circle on social networks, listening to podcasts, and engaging with stories from others. These mechanisms will help you find inspiration for new ideas.

From idea to first line of code

I initiated Veertly in 2019 using React and Create React App. Recently, however, I've been intrigued by NextJS, as one of the most popular React frameworks nowadays. This new project offered the perfect opportunity to explore this framework.

The most effective way to grasp a new framework is to build something with it. I usually start by studying the documentation and watching YouTube videos to get a basic understanding. But the real learning crystallizes when I start coding. Through a cycle of trial and error, I've reached a level where I can confidently say I'm comfortable with NextJS.

I kickstarted the project using NextJS and TypeScript, focusing on experimenting with routes and APIs to understand the mechanics. For the UI and forms, I incorporated shadcn/ui.

The next phase involved diving into Crisp's plugin architecture and libraries.

Understanding Crisp libraries and the plugin framework

After familiarizing myself with NextJS and setting up my repository, the next step was to delve into Crisp's plugin framework and available methods.

Crisp offers extensive capabilities. From extending any functionality to accessing different types of data from the Crisp users and conversations, the SDK coverage is comprehensive.

Types of Crisp Plugins

1. Sidebar widgets for the chatbox
2. Chatbot plugins for message handling
3. Backend integrations for data operations
4. Helpdesk plugins

Sidebar Plugin

In my case, I aimed to develop a sidebar plugin to add a new section in the Crisp sidebar, offering users easy-to-access buttons for executing their custom actions.

Crisp allows two options for sidebar plugins: 1) JSON configuration and 2) iframe embedding. I opted for the latter, as it offers more flexibility and customization. Crisp offers styling options to ensure your plugin aligns with their native look and feel.

In building an iframe-based sidebar widget, consider two key phases:

1. Plugin Installation → Store the unique tokens for each user installation to validate proper access later on the users’ requests.
2. App Embedding → Make your plugin available to end users post-installation by embedding it in the sidebar.

Initially, I overlooked the importance of the installation phase and directly jumped into the embedding process via the Crisp SDK. This is crucial for a safe and robust system.

Crisp API methods

Crisp provides a robust set of methods for interacting with its data. For this plugin, I focused on retrieving:

• User profile basic info
• Conversation metadata
• CRM user profile metadata

I am using the Crisp API methods: getConversation to retrieve conversation details and getPeopleProfile to retrieve CRM user details. As I am calling these methods on my NextJS server components, I'm using Crisp's NodeJS API.

The conversation and users’ data are used in customizing API calls for Quick Actions based on conversation context. When operators configure an action, a list of available variables is presented, which can be used as request parameters or URL components. The same variables are dynamically replaced with real data during action execution.

Database and infrastructure

I'm taking this new journey as an opportunity to dive into Vercel's platform. Vercel is like magic for deploying NextJS apps. You link it to your GitHub repo, and boom — new commits to the main branch get deployed automatically in no time.

In the development of Veertly, I am using GitHub Actions to deploy it to Firebase. Everything is automated, sure, but getting those pipelines and initial setups right was always a bit of a headache. Vercel just makes this step a whole lot easier making it great to just bootstrap a new app.

As for databases, I decided to try Vercel's managed PostgreSQL. My whole experience with Veertly has been mostly hanging around NoSQL, Firebase in particular. So, making the switch back to structured query languages felt like stepping into a time machine. But I decided to give it a try. My needs here aren't super complicated, so why not? Although, I've got to be honest — I'm missing the no-strings-attached vibe of NoSQL databases. Having to define the entire model upfront and tweak the table for new fields is a bit of a culture shock. 🙈 If there are not many relations between the tables, there’s no need to use a SQL database in my opinion. I really appreciate the flexibility of not having a structure in the database.

Dashboard and monitoring

As an indie hacker, you usually don't think much about the after-launch phase or how to monitor things. And I didn't. But as soon as I launched and made it available, I felt the need to know live how things were going and if people were installing my plugin.

In previous projects like Gomada, I used Segment to forward our events to different tools we had, in particular Customer.io and MixPanel. Customer.io allowed us to create workflows when particular events happened and interact via email with users, but also to notify our team on Slack when something happened. Mixpanel was our analytical tool, where we had several dashboards to monitor how many signups and teams were running team-building activities.

However, these tools are overkill for a solopreneur and an initial project, not to mention their expensive cost.

Therefore, for Quick Actions, I decided to make it simpler and try out different mechanisms. Here's what I'm doing:

• Whenever there's a new installation:
  • I trigger a workflow on Make.com that just sends a Slack message to my personal workspace, to get me pumped whenever there's a new user.
  • I add the user to my MailerLite account, which will trigger the onboarding email sequence.
• For my day-to-day monitoring, I implemented a dashboard in Retool that connects directly to the PostgreSQL database. This is a very simple dashboard, but I was able to create it in less than an hour!

• I have also implemented some tracking events in the code that are forwarded to Vercel Analytics, but I'm not exploring them yet. Vercel Analytics is very limited in terms of features; I may consider using MixPanel again, which still has a generous free tier limit.

Plugin approval

In the development of any plugin for any type of tool, you should always consider the approval phase. Each platform has different approval procedures, and it can be a time-consuming process that may bottleneck your launch strategy and timing. So, take that into account from the beginning.

When I started developing, I wasn't fully aware of the approval process. After finishing the main development, I simply pressed the "Publish" button on the Crisp Developer Marketplace. In hindsight, I think I pressed it too early. I had overlooked some key aspects of developing a Crisp plugin, such as handling the correct installation of plugins via their callback mechanism. The Crisp team was incredibly helpful, guiding me toward best practices for plugin development and even providing UX suggestions to make the plugin more user-friendly.

Go-to-market

Initially, I didn't have a concrete go-to-market strategy for Quick Actions; I just wanted to develop something and make it available fast. However, having a clear go-to-market strategy from the start can guide your development and set a clear path for where you want to go and what steps you need to take to get there.

During the plugin's development, I interacted several times with the Crisp team, both via their support chat for technical questions and during the approval phase. Building this relationship was crucial for the success of my plugin.

Once the plugin was approved and made available, the Crisp team featured it in their monthly newsletter. This significantly boosted the number of installations, and I continue to gain new users from it.

Another crucial factor in acquiring new users daily is the plugin's presence in the Crisp integration listing directory. My plugin is part of the automation category, which is the first category of the list of all Crisp plugins — this has been invaluable for marketing and customer acquisition.

Apart from these two tactics, I haven't invested any additional time or resources in marketing. If I decide to expand my customer base, the benefit of developing a plugin like this is the ease of targeting potential users. Cold outreach is a viable option.

As for SEO, I haven't yet solidified my strategy. I'm considering creating guides on integrating Crisp with various tools, similar to what Zapier and Make do. If you have any insights on this, feel free to share; I'd love to discuss it further!

Current usage

As mentioned in previous sections, the Quick Actions plugin has seen consistent installations, totaling over 150+ since the end of August. Considering the minimal marketing effort I've put in, this growth is encouraging and speaks to the benefits of building a plugin for established platforms.

However, the frequency of actions run falls short of my expectations, which would indicate a product-market fit — a critical milestone for any startup or project. I'm not yet there and need to dig deeper into why users aren't using actions more regularly. Some hypotheses include:

• Users may not fully grasp the plugin or its potential functionalities
• The setup process for new actions might be unclear
• Users might desire more integrations but lack the necessary APIs

While I'm confident in the plugin's value — evidenced by the steady influx of new installations — increasing regular usage remains a challenge I aim to address next.

Monetization

I built this plugin as a project to restart my journey of building new projects and learning about NextJS. Monetization was not my core focus when I chose to build this project. Now that I'm seeing more traction and have validated the plugin's usefulness, I need to find ways to monetize it and keep improving it. This, along with achieving product-market fit, is my next big challenge in order to create a sustainable SaaS business.

Disbelieves and fears

As you may have noticed in my story, when I started developing this plugin, I wasn't fully confident in its value. I believed it could be useful, but to what extent? This disbelief is normal for an entrepreneur; we're always questioning ourselves about the usefulness of what we create, and sometimes this plays a negative role in the likelihood of success.

I tend to be on the humble side and only give value to my projects once I have some traction, but I need to fight this feeling. If I had strongly believed in this project from day one, maybe I would have approached onboarding, product-market fit, and monetization differently from the early days, while still keeping efforts to a minimum. On the other hand, now I have a validated product in my hands, so I didn't invest heavily until I knew people were interested in what I was building.

Some errors and things to avoid in the future (this is a note for myself)

After a few months of having launched this plugin, I've had the opportunity to reflect on this journey and what I could've done better:

• Collect user emails from day one → I wanted to keep the installation process as simple as possible, so initially I didn't collect any emails. After a couple of weeks, I made it optional in the onboarding process. Now, there are regular users I can't contact to learn how they're using the product because I don’t have their email...
• Think about user onboarding from the get-go → I neglected the onboarding process initially; users installed the plugin but received no guidance on how to create and run an action. After a few weeks and seeing people install it but struggle to create actions, I revamped the onboarding process to include creating a first action.

• Keep iterating with your users → Talking with users is super crucial. It's important for builders to understand what users glean from your product and how they use it. I'm still lacking in this aspect and need to figure out how to implement these feedback loops.
• Continue guiding your users post-onboarding → I implemented an onboarding email, but it's just one email. I haven't invested much time in product marketing or crafting meaningful onboarding email sequences to help users see the value and get periodic nudges about the product.

Conclusion

In this article, I've reflected on the development journey of the Quick Actions plugin. Here are some key takeaways as I rebooted my builder's journey, from ideation to launch:

• You can only connect the dots looking backward → Revisit your previous experiences and skills for inspiration.
• Keep an open notebook always at hand → Whenever an idea or observation comes to mind, note it down right away. I can't count the number of ideas I've lost by not noting them immediately.
• Engage with stories from others, relate them to your own experiences, and find inspiration for new ideas → Set up mechanisms in your life to let serendipity in.
• Building plugins typically enhances your visibility in platform marketplaces! → leverage existing products in your go-to-market.
• Have product-market fit, onboarding, and monetization in mind from the get-go →Keep a balance between optimizing and speed, but always target these goals.

Embrace serendipity, find your inspiration, and start shipping your products! 🚀

The quicker you ship, the sooner you'll glean meaningful insights from your users. Check my blog post to see how I built one of my latest products in a record 14 hours.

If you're interested in learning more about how I find inspiration and develop my products, follow me or subscribe to my newsletter for the latest tips and guides. I'll begin sharing behind-the-scenes content as well as technical guides on the technologies I use.