Forem: Shayan

🚀 Top 11 Canny Alternatives in 2025

Shayan — Wed, 11 Dec 2024 16:46:40 +0000

If you're looking for alternatives to Canny for collecting and managing user feedback, I have complied a list of 11 alternatives that you can consider.

1. UserJot

Full disclosure: I'm the founder of UserJot. UserJot is a simple feedback management tool that's great for startups. It's has a clean interface and provides everything you need to collect and manage feedback, including a roadmap and changelog. The pricing is affordable, and provides a good free tier for smaller teams. It's a good alternative to Canny if you want a more modern and feature-rich tool.

Website: https://userjot.com

2. UserVoice

UserVoice offers a feedback management platform that's been around for a while. It's got some decent analytics tools and can integrate with quite a few other services. The interface is functional, though it might take some getting used to. It's a solid choice if you need something comprehensive, but it might be overkill for smaller teams.

Website: https://uservoice.com

3. Productboard

Productboard is more of an all-round product management tool that includes feedback collection. It's pretty good at helping you organize and prioritize ideas based on user input. The visual layouts are nice, but some users find the learning curve a bit steep. It's worth considering if you want feedback management as part of a larger product suite.

Website: https://productboard.com

4. Aha!

Aha! is another full-featured product management platform. It's got modules for idea management and roadmapping, which can be handy. The tool is quite extensive, which means it can do a lot, but also that it might be more complex than what some teams need. It's a bit pricey, so it's probably better suited for larger organizations.

Website: https://aha.io

5. Upvoty

Upvoty focuses more specifically on feedback collection and management. It's got a clean interface that makes it easy for users to submit and vote on ideas. The roadmap feature is pretty straightforward. It's a good option if you want something simpler than the big product management suites, though it might lack some advanced features.

Website: https://upvoty.com

6. FeatureOS

FeatureOS tries to cover all the bases with feedback boards, roadmaps, and changelog features. It's got a modern look and feel, which is nice. The pricing is reasonable for what you get. Some users mention that certain features could be more fleshed out, but overall it's a decent all-in-one option.

Website: https://featureos.app

7. Frill

Frill keeps things relatively simple with its feedback management and roadmap tools. The voting system is straightforward, which users tend to appreciate. It's not as feature-rich as some other options, but that might be a plus if you're after something more streamlined. The pricing is pretty competitive too.

Website: https://frill.co

8. Feedbear

Feedbear offers a no-frills approach to feedback collection and management. It's got the basics covered with boards, roadmaps, and announcements. The interface is clean, if a bit basic. It's a good choice if you want something easy to set up and use, though power users might find it lacking in some areas.

Website: https://feedbear.com

9. Nolt

Nolt keeps things really simple with its feedback boards. Users can submit and vote on ideas, and that's pretty much it. The minimalist approach means it's easy to get started with, but you might outgrow it if you need more advanced features. It's worth a look if you just want a basic voting board without the bells and whistles.

Website: https://nolt.io

10. Usersnap

Usersnap takes a slightly different approach by focusing on visual feedback. Users can annotate screenshots, which can be helpful for certain types of products. It also has more traditional feedback management features. The visual element is nice, but it might not be necessary for all types of feedback.

Website: https://usersnap.com

11. Feature Upvote

Feature Upvote does what it says on the tin - it lets users suggest and vote on features. It's pretty bare-bones, which can be good or bad depending on your needs. The customization options are decent. It's worth considering if you just need a simple voting mechanism without much else.

Website: https://featureupvote.com

Remember, the best tool depends on your specific needs, team size, and budget. It's worth trying out a few to see which one feels right for your workflow.

Get push notifications from Javascript in just one minute!

Shayan — Thu, 27 Jan 2022 20:36:30 +0000

There have been many times when, as a developer, I wanted to be notified and track certain events that happened within my projects. For example, when a user joins a newsletter, creates an account, upgrades to a premium plan, or provides feedback.

LogSnag makes it very easy to set up these notifications and creates feeds of events so you can be aware of what happened and when it happened.

Getting Started

First, I will add a new project to my LogSnag account. Let's call it my-saas for this example.

Next, we need an API token. Head to the settings, open the API tab, and use the + button to create a new token. You can then use the clipboard icon to copy the token.

We are almost done! Let's move to our code!

Javascript Time!

First, let's install the LogSnag npm package

npm install --save logsnag

Then, we have to import the package and initialize our client with the API token that we just copied from the application.

import { LogSnag } from 'logsnag';

const logsnag = new LogSnag('MY_API_TOKEN')

Finally, we can use our client to publish any events from our application.

For this example, I will call my channel waitlist as I would like to be notified and keep track of users who join my waitlist. Since this is the first time we publish to this channel, LogSnag will automatically create it for us.

I'm going to pass in the user email in the description and use the unicorn emoji as the icon. Most importantly, I will set notify to true since I would like to receive a push notification for this event.

logsnag.publish({
    project: "my-saas",
    channel: "waitlist",
    event: "User Joined Waitlist",
    description: "email: john.doe@yahoo.com",
    icon: "🦄",
    notify: true
})

Once we run this code, a new channel is created under the my-saas project and we get push notifications for this event on all of the devices that have LogSnag installed!

LogSnag has been a side project for the past couple of months. It has originated from the pain points of using messaging platforms to publish and track user activity and events. LogSnag has been explicitly designed for this purpose and provides powerful features that make it much easier to track events and projects. Currently, LogSnag is in the beta stage, and you can get access by signing up for the waitlist on the website.

How to Send your Events and Logs to Discord via Python or JavaScript

Shayan — Mon, 15 Nov 2021 18:29:43 +0000

Update: I have recently started working on a new project to keep track of events from my projects which I use now over Discord. I would love to hear your feedback on the project: LogSnag - Track your projects' events

Throughout my software development career, there were many times when I wanted to get instant updates and alerts when something happened within my project.

Take this, for example; you are developing a SaaS, and there are multiple valuable events that you would like to be aware of as soon as they happen. For example, users joining your waitlist or newsletter, user sign-ups, product sales, and user conversions. Having to run a long training or crawling task on a remote machine was another situation where I wanted instant updates on the progress and if something had gone wrong. I mean, you can do periodic checks on the machine to see how things are going, but I’d rather entirely forget about it and have it send me updates instead. The last example is when I wanted to automate my garage door via raspberry pi and I wanted to know when the garage door was opening, closing, or had been left open for too long.

So why am I telling you these examples? I want you to start thinking about similar situations that you may also need a way to send yourself instant updates and to have a history of all these events in a single place.

Discord makes it relatively easy to solve this problem! We can create a Discord server specifically, create separate channels for our projects and use the webhook URL to push our events!

To get started, we need that Discord server. Log in to Discord, click on the Add Server button and proceed to create your own. Once that’s done, you should be able to see and open your Discord server

To make it easier to organize my projects and events, I usually create a new text channel for each project or, in some cases, one per type of event. To do so, click the + button next to text channels and create one. I’m going to call mine garage-door and make it a private channel.

Then, click on the settings icon for that channel, open the integration tab and create a new Webhook. Once added, you can see the Copy Webhook URL, and that’s precisely what we need to push our events! So copy that and paste it somewhere safe on your machine. Now, we are pretty much done with Discord, and we can move to writing some code! I have provided examples for Python and JavaScript; feel free to skip to whichever you find more relevant.

Sending events via Python

First, I would like to pass in my webhook URL as an environment variable, so I will set it to WEBHOOK_URL and use the standard library in python to access the value. You can, of course, skip this entire process and add your URL directly to the code.

export WEBHOOK_URL=https://discord.com/api/...

Once we have set the environment variable, we can access it by importing os and using the os.environ.get method.

import os

WEBHOOK_URL = os.environ.get('WEBHOOK_URL')
print(WEBHOOK_URL)

I will be using the requests package to handle my HTTP requests. You can install via PyPi by running the following command.

pip install requests

Finally, all we need to do is to import requests and make a POST request to the webhook url and pass our event in the JSON body with the content key.

import requests

requests.post(WEBHOOK_URL, { "content": "🦄 garage door is open" })

Once we run this code, we should get a new message in the garage-door channel telling us that our garage door has been opened.

Sending events via JavaScript

The process here is very similar to what we did in Python. First, define a new environment variable called WEBHOOK_URL for the webhook URL that we copied from discord. Again, you can skip this step and directly set the URL to a variable.

export WEBHOOK_URL=https://discord.com/api/...

Then, read this value process.env.WEBHOOK_URL and set it to a variable.

const WEBHOOK_URL = process.env.WEBHOOK_URL
console.log(WEBHOOK_URL)

I will be using the Axios package to handle my HTTP requests. You can install via NPM by running the following command.

npm i axios

Finally, we can import Axios and make a POST request to the webhook url and pass in our event in the JSON body.

import axios from 'axios';

await axios.post(WEBHOOK_URL, { content: "💰 User sign up" })

Once we run this code, we should see another message in our Discord channel.

As you can see, getting this set up is very easy while being quite powerful! I use this setup in almost all of my projects to be aware of how they are doing!

Use Python or JavaScript to Send Your Events and Logs to Telegram via their Chatbot API

Shayan — Sat, 13 Nov 2021 17:54:56 +0000

Update: I have recently started working on a new project to keep track of events from my projects which I use now over Telegram. I would love to hear your feedback on the project: LogSnag - Track your projects' events

In my opinion, Telegram has one of the best, if not the best, chatbot API. What they have created is extremely easy to use, yet it is unbelievably powerful. And I have used it for dozens of small projects over the years. One of my prominent use cases for their API is to send myself events and logs from my applications and projects.

Consider this example; you are developing a new project for which you may need to crawl hundreds or thousands of web pages or any other similar long-running tasks. You would deploy this script to a VM, or maybe your machine, and let it run for the next day or two. But, how do you usually check on the progress? Do you ssh to the VM, find the right tmux session, and read the logs? What if you want to leave home and don’t have access to the computer? Well, this is one of those situations that made me think… “hmm, what if I could use Telegram as a remote output?” I mean, the API is very, very easy to use, and all I need to do is to make an HTTP request to their endpoint, so why not?

This is just one of the dozens of examples where I found it convenient to push events to myself, and ever since, I have used it for many different projects to update myself on user actions, product sales, hell even stock prices. So in this blog post, I will be going over how to set up your first chatbot and how to send events to yourself via Python or JavaScript :)

Register a Telegram Chatbot.

Alright, the first step is to message @botfather on Telegram and to create your first chatbot! The process is very straightforward, as you can see in the following screenshot.

Let’s copy the API token and add it to our environment variables. You can, of course, skip this process and add it directly to your code. Also, make sure to keep this token private! I will be revoking mine after writing this post.

export BOT_TOKEN=2104030722:AAGdY_FeAFqvriecqv3lhissc-uG4t0arL4

Find your telegram Chat Id

Ok, we have one more step to do before getting our hands dirty with some code. Thankfully this one is straightforward, we have to find our chat_id in Telegram, and there are multiple ways to find it. I will be using the chatbot API to find out my chat_id.

So, open the chatbot we have just created and send it a message; it could be anything. Then, make a get request to the following URL with your API token, using your browser or postman, and it should tell you your chat_id.

// template
[https://api.telegram.org/bot](https://api.telegram.org/bot)<BOT_TOKEN>/getUpdates

// how mine looks like with my bot token
[https://api.telegram.org/bot2104030722:AAGdY_FeAFqvriecqv3lhissc-uG4t0arL4/getUpdates](https://api.telegram.org/bot2104030722:AAGdY_FeAFqvriecqv3lhissc-uG4t0arL4/getUpdates)

As you see in the screenshot, you can see your chat_id via the following path result[].message.chat.id. Copy and again, add it to your environment variables or paste directly in the code.

export CHAT_ID=<MY_CHAT_ID>

Ok, that’s pretty much all we had to do with Telegram; let’s write some code. For this post, I will be providing an example with Python and JavaScript, so feel free to skip to whichever one you prefer.

Publishing Events via Python

First, let’s access our environment variables and assign them to variables

import os

BOT_TOKEN = os.environ.get('BOT_TOKEN')
CHAT_ID = os.environ.get('CHAT_ID')

I will be using the requests package to handle my HTTP requests. So, let’s also install that via PyPi by running the following command.

pip install requests

Awesome! Now let’s define a method for sending our events to Telegram. We’re going to call it send_message, and it will need to accept a message string.

def send_message(msg):

Then, we will add Telegram’s send message endpoint and populate it via our bot token.

url = f”https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"

Next, let’s define the URL parameters that we need to send to Telegram. We need a chat_id, and text and by now, we should have both ready.

params = { “chat_id”: CHAT_ID, “text”: msg }

Finally, we will import requests and make a GET request and pass in our URL parameters.

requests.get(url, params=params)

Putting these all together, our method should look like the following.

import requests

def send_message(msg):
   url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
   params = { "chat_id": CHAT_ID, "text": msg }
   requests.get(url, params=params)

That’s pretty much it :) Now we can send whatever event that we have to ourselves through Telegram. So, remember the crawler job? Imagine we want to send periodic progress. We can do something like this:

send_message(“🔥 Crawling progress: 56% done”)

Once we run our code, if everything goes right, we should see something like this. How cool is that?

Publishing Events via JavaScript

Ok, let’s repeat the same process in JavaScript. First, let’s access our environment variables and set them to variables.

const BOT_TOKEN = process.env.BOT_TOKEN
const CHAT_ID = process.env.CHAT_ID

Next, I will be using the Axios package to handle my HTTP requests. You can install via NPM by running the following command.

npm i axios

Now, let’s define our sendMessage method. It needs to take our string message as an argument. Then we will add the endpoint URL and populate it via our BOT_TOKEN. Next, let’s define our URL parameters required by Telegram; chat_id and text. Finally, we can make our get request via Axios and pass in our params.

import axios from 'axios';

const BOT_TOKEN = process.env.BOT_TOKEN
const CHAT_ID = process.env.CHAT_ID

async function sendMessage(message) {
    const url = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`
    const params = { chat_id: CHAT_ID, text: message }
    await axios.get(url, { params: params })
}

That’s pretty much it! Let’s give this one a shot as well.

await sendMessage("💰 New user signed up")

That’s pretty much it! By adding these couple of lines, we get another superpower that we can use for almost anything!

How I Created an Event-Driven Backend with RxJS, Server-Sent Events, Express and NodeJS

Shayan — Sat, 29 May 2021 20:36:28 +0000

About a month ago, a friend and I came up with an idea for a small website and decided to create an MVP in a couple of days to give it a shot. The idea was pretty simple; a meme-driven chat room and a live price chart for each cryptocurrency. I was assigned to create the backend for the project, and my friend would make the web client.

I set three requirements for myself before starting to work on the server. First and foremost, I wanted to get the MVP out as soon as possible. Secondly, I wanted to make the server as lightweight as possible to just leave it running on a cheap VM. Lastly, I wanted to design the architecture to allow for easy scaling if the shit coin investors decide to make another stupid decision and use our application.

The first step was to think of the entire server as a pipeline. Basically, the whole thing is a pipeline that consumes a set of events, processes them, and then streams them to many clients.

Any incoming data can be considered as some sort of event. For example, we have things like users joining or leaving a room, publishing or deleting comments, and ticker price updates. On the other side, anything that consumes these events can be considered as a client; our database, cache, and every connected browser.

After giving this a bit more thought, the first thing that came to my mind was a combination of RxJS and Server-Sent Events. I have never written a server-side javascript project as I mainly use Golang and Python, but I really wanted to experiment with RxJS on the server-side, and this seemed to be the perfect time to give it a shot.

To explain the implementation in more detail, I will walk through implementing a very simple stock/cryptocurrency live price streaming endpoint. First, we need a RxJS Subject which is a multicast observable. Our subject will take care of streaming the ticker price events to all of our clients (subscribers).

import { Subject } from 'rxjs';
import { filter, map } from 'rxjs/operators';
// our RxJS subject
const TickerSubject = new Subject();

Next, we need an entry point for our events to be pushed to our stream. We can either emit directly to our subject or create a wrapper function as an abstraction layer and sanitize and check our data before emitting new events.

To do so, let's define a function called EmitTickerPrice. Every time we get a new ticker price data, we will call this method with the proper parameters, and it will emit a new event to our ticker subject.

/**
 * Emit a new ticker price
 * @param {string} symbol: ticker symbol
 * @param {string} price: ticker price
 * @param {string} currency: ticker currency
 */
const EmitTickerPrice = async (symbol, price, currency) => {
    const ticker = {
        symbol, price, currency,
        createdAt: Math.floor(new Date() / 1000),
    };
    TickerSubject.next(ticker);
    return ticker;
};

For our project, I am using PostgreSQL to persist historical ticker price information. I am also using Redis as a cache store to reduce the database load when clients request the data to render the price chart. As I mentioned previously, each of these is considered a client and independently subscribed to our RxJS subjects. We can call subscribe on our ticker subject and pass a callback method to observe and handle each incoming event.

TickerSubject.subscribe(ticker => {})

Pretty easy, right? Well, not really. See, for our website, we are pushing a new ticker price event every five seconds for each supported stock and cryptocurrency ticker. These events are also not synchronized and come in at different intervals, which means that we get dozens of ticker events every second. The problem is that we don't want to call our Redis and PostgreSQL subscriber callback every time a new event is emitted. Instead, we want to implement some additional logic in our pipeline to reduce the load on these services.

PostgreSQL Observer

Let's start with PostgreSQL; inserting a new row individually each time a new ticker price is emitted is not ideal. This may differ for the different projects as, in some cases, we may need atomic inserts. However, for this project, the 30 seconds insertion delay was negligible. Luckily, RxJS makes it very easy to implement this feature by providing pipelines and dozens of operators. For our case, we can create a pipe and use the bufferTime operator to buffer our events for 30,000 milliseconds. Then, we can subscribe to the newly defined pipeline.

Let's start with PostgreSQL; inserting a new row individually each time a new ticker price is emitted is not ideal. This may differ for the different projects as, in some cases, we may need atomic inserts. However, for this project, the 30 seconds insertion delay was negligible. Luckily, RxJS makes it very easy to implement this feature by providing pipelines and dozens of operators. For our case, we can create a pipe and use the bufferTime operator to buffer our events for 30,000 milliseconds. Then, we can subscribe to the newly defined pipeline.

import { bufferTime } from 'rxjs/operators';
TickerSubject.TickerSubject.pipe(
    bufferTime(30000),
).subscribe(tickers => {})

Our subscriber is called every 30 seconds, and it gets a list of buffered events in the past buffer period instead.

Redis Observer

Our problem gets a bit more interesting with Redis. As I mentioned previously, Redis is mainly used to cache the price points needed to generate the price chart displayed on the website.

This chart is created for the different intervals such as the past 5 minutes, one hour, or a day. As you can tell by now, we don't need a data point every 5 seconds for our 24-hour chart; instead, a data point every 30 minutes or even an hour would do the job.

Our Redis observer should throttle each unique ticker symbol for 30 minutes before calling the subscriber. To achieve this, we need to create a bit more complicated pipeline than what we previously had for the PostgreSQL observer.

First, we have to group our events based on their ticker symbol. To do so, we can use the groupBy operator provided by RxJS and provide an arrow function to specify how we are grouping these events. We want the group our events based on their ticker symbols; hence, we return the ticker symbol value from our arrow function.

Next, we will throttle each group to emit once every 30 minutes and finally merge all the groups into a single pipeline. We can use the mergeMap operator and map through each group to add the throttleTime operator with a 30-minute interval. Finally, we can subscribe to the pipeline and insert the data into our Redis server.

import { groupBy, mergeMap, throttleTime } from 'rxjs/operators';
TickerSubject.pipe(
    groupBy((ticker) => ticker.symbol),
    mergeMap((group) => group.pipe(
        throttleTime(30 * 60 * 1000),
    )),
).subscribe(ticker => {})

We can even go further and buffer these events to take advantage of Redis pipelines, but I will skip that part as it will look almost identical to what we did with our PostgreSQL pipeline.

If you made it thus far, pat yourself on the back, take a deep breath and go get some coffee before we get our hands dirty with server-sent events.

Server-Sent Events Endpoint

For our website, I am using ExpressJS and the @awaitjs/express library to use async/await in my routers. Register the path /ticker/:symbol/event via GET method on our express server to create our server-sent events route.

Router.getAsync('/ticker/:symbol/event', async (req, res) => {})

To enable SSE, we need to flush a couple of headers back to our client. We want the Connection set to keep-alive, Cache-Control set to no-cache and Content-Type set to text/event-stream so our client would understand that this is an SSE route.

In addition, I have added Access-Control-Allow-Origin to for CORS and X-Accel-Buffering set to no to avoid Nginx from messing with this route. Finally, we can flush the headers back to our client to kickstart the event stream.

Router.getAsync('/ticker/:symbol/event',
    async (req, res) => {
        res.setHeader('Cache-Control', 'no-cache');
        res.setHeader('Content-Type', 'text/event-stream');
        res.setHeader('Connection', 'keep-alive');
        res.setHeader('Access-Control-Allow-Origin', '*');
        res.setHeader('X-Accel-Buffering', 'no');
        res.flushHeaders();
});

We can now start streaming data by writing something into our response. SSE provides a text-based protocol that we can use to help our clients differentiate between the event types. Each one of our events should look like the following:

event: ${event name}\n
data: ${event data}\n\n

To make our lives a bit easier, I have created a helper function to take care of serialization for us.

/**javascript
 * SSE message serializer
 * @param {string} event: Event name
 * @param {Object} data: Event data
 * @returns {string}
 */
const EventSerializer = (event, data) => {
    const jsonString = JSON.stringify(data);
    return `event: ${event}\ndata: ${jsonString}\n\n`;
};

On our website, we have half a dozen subjects similar to what we have created so far. To be able to differentiate between these events, we have to assign an event name to each. Let's use price_update for the ticker subject. In addition, we need to filter these events based on the dynamic path that our client has subscribed. For example, on /ticker/DOGE/event, we only want events related to Dogecoin. To implement these two features, let's create a new wrapper around our ticker subject to filter the pipeline and add our event name to the events.

import { filter, map } from 'rxjs/operators';
/**
 * Event stream for ticker price update
 * @param {string} symbol: ticker symbol
 * @returns {Observable<{data: *, name: string}>}
 */
function EventTickerStream(symbol) {
   return TickerSubject
      .pipe(
         filter((ticker) => ticker.symbol === symbol),
         map((ticker) => {
            return { data: ticker, name: 'price_update' };
         }
      ),
   );
}

All left to do is merge these events into a single pipeline and create a new subscriber to write them into the SSE connection. We can take use the of operator to create a pipeline from all of our subjects. Then, we use the mergeAll operator to collect and merge all of our observables into a single observable. Then, we can subscribe to the observable, serialize our data and write it to our response. Finally, we have to make sure to unsubscribe from our observer when the SSE connection is closed. Putting all of these together, we should have something like the following

import { of } from 'rxjs';
import { mergeAll } from 'rxjs/operators';
Router.getAsync('/ticker/:symbol/event',
    async (req, res) => {
        res.setHeader('Cache-Control', 'no-cache');
        res.setHeader('Content-Type', 'text/event-stream');
        res.setHeader('Connection', 'keep-alive');
        res.setHeader('Access-Control-Allow-Origin', '*');
        res.setHeader('X-Accel-Buffering', 'no');
        res.flushHeaders();
        const symbol = req.params.symbol.toUpperCase();
        const stream$ = of(
            EventTickerStream(symbol),
            // other events ...
        ).pipe(
            mergeAll(),
        ).subscribe((event) => {
            res.write(EventSerializer(event.name, event.data));
        });
        req.on('close', () => {
            stream$.unsubscribe();
        });
});

Aaannddd… that's it! We are done with our backend server.
Here's an overall view of what we have created so far.

Server-Sent Events Client

To subscribe to our SSE route, we can create a new instance of the EventSource interface and pass our endpoint to the constructor. Once we have an instance, we can add event handlers for specific event names to process the incoming data. In our case, we can subscribe to the price_update event for Dogecoin and use the data to update our UI.

const eventSource = new EventSource("/ticker/DOGE/event");
eventSource.addEventListener(
   "price_update", (event) => {
       const data = JSON.parse(event.data);
       // use the data to update the UI
    }, false
);
// close the connection when needed
eventSource.close();

At the end of the day, I am pleased about this architecture as it satisfies most of my requirements for this project. Going with a reactive design allowed me to implement many complex features more efficiently and less error-prone than an imperative model. Higher-level functions provided by RxJS, such as throttleTime and bufferTime solved many of my problems very quickly and saved me a lot of development time. Completing the first iteration of the MVP took us about 4 days.

I also wanted to deploy our services on the smallest virtual machine to reduce costs and benchmark server-side performance. Thus, I went with the $5/month digital ocean droplet. Over the last week, our server has served over 3.7M requests and over 120M events, and at one point, we had over 500 concurrent clients, which I think is a pretty damn good benchmark.

In terms of scalability, we still have a lot of room to grow vertically and increase the resources available on the VM. But if we want to grow horizontally, the current architecture allows us to deploy proxies that subscribe to our pipelines, either through our SSE endpoint or to the subjects over the network, and then multiplex the events to more clients.

That concludes the discussion on how I implemented an event-driven server for our project. You can check out the final result at Monke Cafe.

Thank you for reading; if you would like to chat, you can find me on Twitter @imsh4yy or via responses here.

Update: I have recently started working on a new project and have been using the same architecture design for pushing down information to my users. I would love to hear your feedback on the project: checkridehq.com, LogSnag - Track your projects' events