DEV Community: TagorenathV

Supabase: Easy to Ship. Hard to Maintain.

TagorenathV — Tue, 24 Feb 2026 04:21:41 +0000

In the modern founder's toolkit, Supabase is the ultimate accelerator. Personally, we've replaced Firebase with Supabase for most of our projects, and it has become our default starting point for a while.

Supabase bundles the world's most powerful database (Postgres) with everything else: Authentication, Data APIs, Edge functions, Realtime subscriptions, Storage, and Vector embeddings. It makes the "Zero to One" phase feel like magic.

Over time, experience has taught me a hard lesson: Shipping is just Step One. The true shades of a product only emerge once the traffic starts flowing.

Development vs. Production

When we are building, we optimize for velocity. We measure progress by features shipped. We move fast, we push changes quickly, we break things, and we celebrate when we hit "Live".

But production plays by different rules. Once traffic starts flowing in, we are no longer optimizing for features; we are optimizing for stability/predictability.

Suddenly, the questions change to :

Is the system predictable?
Are users seeing consistent performance?
Can we handle growth without surprises?

Development hides complexity. Production exposes it.

Postgres: Great Power with Responsibility

Supabase, being built on Postgres, is both its greatest strength and its most underappreciated responsibility. Postgres is genuinely extraordinary; it's powerful and reliable. But once we're live, we start seeing the other side of that power: operational responsibility.

When our application is live, we need answers to questions that don't show up during development, and a standard dashboard doesn't always warn us:

Are there missing indexes slowing down the 99th percentile of users?
Are long-running queries blocking others?
Do we have connection saturation?
Is table bloat accumulating over time, thereby throttling performance?
Are locks affecting performance?

We learned this the hard way. Six months after launch, our p99 response times had been silently climbing for weeks. No alert had fired. We dug in and found a missing index on a query that ran perfectly during testing with a few hundred rows, but was doing a full sequential scan across two million in production. Nobody warned us. We just happened to look.

Most of the time, we handle these things reactively. We either wait for a user to complain or for the application to go down.

The Reactive Pattern

If we're honest, the default operating mode for most early-stage teams is reactive. We respond to fires instead of preventing them. Not because we're careless, but because when we're moving fast, monitoring feels like a "later" problem. And "later" has a way of arriving without warning.

This is what I've come to think of as the Operational Maturity gap. It's not a code problem or a product problem. It's the gap between a system that was built to ship and a system that was built to run. Most startups fall into it somewhere between their first thousand users and their first serious incident.

Stability is the Ultimate Feature

Users don't care about our stack. They care if it works, if it's fast, if it's reliable. To retain our users on our platform, we have to move beyond just managed services.

We need "consolidated visibility". We need to know how our platform is behaving before the bottleneck becomes a crash. We need to measure confidence.

Shipping fast is a competitive advantage. But staying stable is how we actually build trust, and trust is what builds a business.

Building a Serverless Slack App using Python and AWS SAM

TagorenathV — Sun, 28 Jan 2024 19:43:09 +0000

Slack, a widely used collaboration platform, enables teams to communicate, share files, and collaborate effectively. By integrating custom Slack apps, teams can enhance this experience by automating tasks and adding unique functionalities tailored to their specific needs.

One way to deploy Slack apps is through a serverless architecture, which offers several advantages such as scalability, cost-efficiency, reduced operational burden, and increased development speed.

This guide will walk you through the process of building a serverless Slack app using AWS and Python. It provides a step-by-step approach to leverage these benefits and enhance Slack's capabilities effectively and efficiently.

💡You can find the complete code for this tutorial at the following link: GitHub Repository.
Dive in to explore and use the code for building your serverless Slack app.

Step 0: Setup

Before starting your serverless Slack app project, ensure you have the following set up:

An AWS account for deploying and managing your app.
AWS CLI is installed on your machine for easy AWS services interaction.
AWS SAM (Serverless Application Model) for streamlining serverless app development.
Python and pip for writing your app and managing dependencies.

With these tools, you're ready to build and deploy your serverless Slack app efficiently.

Step 1: Create a new AWS SAM project

To begin building your serverless Slack app, use the AWS SAM CLI to create a new project. Open your terminal and run the following command:

sam init --runtime python3.10 --name serverless-slack-app --app-template hello-world

This command will create a new AWS SAM project with a basic "Hello World" function. It sets up the necessary structure and files for your app as below:

Step 2: Configure the Slack app

Create a New App: To interact with the Slack platform, you need an app. To set up your Slack app, visit https://api.slack.com/apps, click on “Create New App”, select “From Scratch”, then enter your “App Name” and choose the workspace you want to install it in.

Configure OAuth & Permissions: Go to the 'OAuth & Permissions' tab. Specify the scopes your app requires to operate. These scopes define the permissions your app has in the Slack workspace, like sending messages or accessing user data.

Install App to Workspace: Once the permissions are set, install the app to your workspace. This step might prompt you to authorize the app with the specified permissions.

Obtain API Credentials: Once the App is installed, you can find an OAuth token. This we will be using further in our app to communicate with Slack.

Step 3: Implement the Slack functionality

Navigate to the AWS SAM project and follow these steps:

Add slack-sdk dependency to requirements.txt file
In app.py file implement the necessary code to handle Slack events and commands. As part of the blog, we will have code to respond url_verification challenge & app_mention.

# Parse the incoming event data from Slack
slack_event = json.loads(event["body"])

# Check for URL verification during the event subscription process
if slack_event.get("type") == "url_verification":
    # Respond with the challenge token to verify the endpoint
    return {"statusCode": 200, "body": slack_event.get("challenge")}
elif slack_event.get("event"):
    # Extract the event data
    data = slack_event.get("event")
    event_type = data.get("type")

    # Check if the event is an app mention
    if event_type == "app_mention":
        # Get the channel ID from the event data
        channel_id = data.get("channel")
        # Post a greeting message in the channel where the app was mentioned
        client.chat_postMessage(channel=channel_id, text="👋 Hello there! I'm Serverless Slack App, here to make your day a little easier. 😊")
        return

You can leverage the power of Python to process events and perform operations with Slack, such as sending messages, retrieving information, or triggering external services. The Python Slack SDK provides an interface for interacting with the Slack API, simplifying development.

Slack's Block Kit is a UI framework for creating rich and interactive app interfaces. It allows you to build engaging messages and modals, enhancing the user experience. By combining the Python Slack SDK with Block Kit, you can develop user-friendly Slack apps that provide a seamless and engaging interaction.

Step 4: Deploy the app

Once you have implemented the desired functionality for your serverless Slack app, it's time to deploy it to AWS Lambda. This allows your app to run in a serverless environment without the need to manage servers or infrastructure.

Update template.yaml file as below:

Remove the below blocks:

# remove Events section in HelloWorldFunction under resources:
Events:
  HelloWorld:
    Type: Api # More info about API Event Source: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
    Properties:
      Path: /hello
      Method: get

# remove HelloWorldApi section in Outputs:
HelloWorldApi:
  Description: "API Gateway endpoint URL for Prod stage for Hello World function"
  Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"

Add below blocks:

# Add under HelloWorldFunction in resources section:
FunctionUrlConfig:
  AuthType: NONE
  InvokeMode: BUFFERED
  Cors:
    AllowCredentials: false
    AllowMethods:
      - POST
      - GET
    AllowOrigins:
      - "*"
Policies:
  - AWSLambdaExecute
Environment:
  Variables:
    SLACK_BOT_TOKEN: <your slack oauth2 token here>

To deploy your app, run the following command in your terminal:

sam build
sam deploy --guided

The AWS SAM CLI will guide you through the deployment process, prompting you to configure the deployment options and resources. Ensure to provide the necessary information, such as the AWS region, app name, and credentials.

Once deployed, you will see Cloudformation outputs as:

Step 5: Subscribe to Bot Events

To set up event handling, go to the "Event Subscriptions" section in your Slack app settings and paste the Lambda Function URL you received after deploying your app. Slack will automatically send a verification challenge to this URL to validate the connection. Once Slack successfully verifies the URL, your app will be ready to receive and respond to events from Slack. Add required bot user events and save.

Step 6: Test

After setting up your serverless Slack app, it’s essential to test it to ensure it responds correctly within your Slack workspace. Mention your app in a channel by typing @serverless-slack-app Hello. If everything is configured properly, the app should reply with a greeting. This confirmation indicates that your app is operational and ready to interact with users in your workspace.

Resources

Github repo for this blog: https://github.com/tagorenathv/serverless-slack-app
Serverless ShiftRoster app link: https://github.com/tagorenathv/slack-shift-roster
New slack workspace link: https://slack.com/get-started#/createnew
Slack Python guide: https://slack.dev/bolt-python/tutorial/getting-started
AWS SAM: https://docs.aws.amazon.com/serverless-application-model/

Wrapping Up

Wrapping up, you now have a foundational serverless Slack bot, poised for expansion and customization. The journey doesn't end here; the Slack API, coupled with Python's versatility, opens up a plethora of opportunities for further development.

Stay curious, keep coding!🚀

IoT-SaaS: Web App using ReactJS, MongoDB Atlas & Realm

TagorenathV — Tue, 11 Jan 2022 12:41:56 +0000

Overview of My Submission

Nowadays, SaaS platforms & IoT devices are gaining popularity in a variety of use-cases. I built a prototype for IoT based SaaS platform for aquaculture. Users can register to the platform, subscribe to a device and get Real-Time alerts and Dashboards on the fly. Importantly, Pay-as-you-use.

Though IoT use cases primarily focus on Timeseries collections, I tried to include random features as much as possible to experience different MongoDB features with this proto-type project.

Submission Category:

Prime Time

Link to Code

https://github.com/tagorenathv/iot-saas

Tool Stack Used

All data stored in MongoDB Atlas
Timeseries collection for storing sensor_data with granularity and expireAfterSeconds defined
Atlas Search: Search Index on device collection for fields: title with analyzers & mapping defined for Autocompletition functianality
Text Index on device collection for fields: title and description for Full-Text search functionality, including spell corrections
Scheduled-Triggers for:
- simulating data
- calculating aggregated sensor data values
- generating bills every month
Database-Triggers on every aggregated-value to check alert condition and insert into alert collection if any
Used Realm-Functions for performing data manipulations present in MongoDB Atlas collections
Frontend made with React JS, ant.design UI library and used Realm-Web-Client SDK for calling Realm-Functions
Used Email/Password provider of Realm-Authentication for UI authentication
Applied Realm-DataAccess Rules for added layer of Authorization for each collection
Hosted react application on Realm-Hosting

Demo

To Watch: Link-1 or Link-2
To Experience: iot-saas

Wana Try?

Please follow README file for setup details and also to understand how different MongoDB services are combined together to perform some action in this project

Take-Aways

My Take-Aways on MongoDB ecosystem after this project

MongoDB ecosystem has evolved at its best, making developers life easy and bringing ideas into existance with matter of clicks! Importantly, no need to go for other services. One stop solution for all your usecases.
Want Autocomplete feature? Use Atlas-Search. No more replicating data to Elasticsearch
Want Timeseries feature? Use Timeseries collection. Utilize granularity and expireAfterSeconds for data archivals and performance enhacement Out-of-the-box. (P.S: Use Atlas cluster from v5.0 for Timeseries collections)
Want Full-Text search feature? Create Text-Index on collection. No more replicating data to Elasticsearch
Want Authentication? Use Realm-Authentication
Want Authorization? Use Realm-Rules
Want Event-Driven triggers both Scheduled & Database? - Use Realm-Triggers
Want to access data Serverlessly without backend? Use Realm-Client SDKs or Enable HTTP Endpoints
Want to host your application? Use Realm-Hosting
and lot lot lot more out-of-the-box

What else could be better?

PS.: In my opinion

Times I felt, documentation is misleading. Navigations could be more clear
Folders uploading not available at Realm-Hosting UI. Need to create folders and upload files individually if needed. Would save time if this is available from UI
At Realm-Deployment, it would be helpful to modify all json configuration files and deploy from UI itself. External & Github actions are quite helpful thought.
Eagerly waiting for Flutter Realm-SDK GA. Can't wait to use two best things for a project 🔥🔥🔥

Additional Resources / Info

PS: Project is built and hosted with MongoDB ecosystem and ❤️