From CANT.study → Notesy.ai → ANTM.ai

Our journey began with CANT.study, a context-aware lecture transcription tool—born during “Build Night” while working live in public. From there, we experimented with broader note-taking concepts under Notesy.ai, capturing multi-source information. Now, we’re proud to present ANTM.ai Brain 2.0: a full-featured, AI-powered memory graph built on those principles.

The Vision Behind Brain 2.0

Tools today let you store text, audio, and links—but few turn that data into connections. We saw an opportunity:

• Capture from anywhere—browser, email, voice, chat.

• Use a knowledge graph to represent ideas as interconnected nodes and edges.

• Continuously enhance your “brain” by discovering new patterns and suggestions.

How Brain 2.0 Works

1. Capture Everywhere

   • Web clipper for articles

   • Forwarded emails and chats

   • Voice and meeting transcription

2. AI Processing

   • Transcribe and embed content

   • Auto-tag items and identify entities

   • Establish connections automatically, creating a living graph

3. Discover Insights

   • Ask questions in natural language

   • Navigate your dynamic graph visually

   • Receive context-aware reminders and alerts

Core Features

Technical Highlights

• Graph Memory Engine: Real-time knowledge graph model enabling temporal and context-rich connections.

• Multi-modal Inputs: Integrates text, voice, and rich content into unified processing pipelines.

• Graph-RAG Combiner: Supports multi-hop reasoning over the graph for nuanced query responses.

What’s Ahead

1. Open Beta: Launching with web clipper, email/voice capture, and basic graph recall.

2. Graph Intelligence: Introducing auto-edge creation and logical connection inference.

3. Collaborative Spaces: Share graphs with teams and surface collective insights.

4. Agent Automations: Scheduled summaries, relationship alerts, and reminder agents.

Why It Matters

• Transforms static notes into a reflective, evolving brain—mirroring how we actually think.

• Builds on lessons from CANT.study and Notesy.ai, refined through Build Night’s transparent, feedback-driven development.

• Offers intelligent recall and insight, so you can focus on thinking—not remembering.

Brain 2.0 through ANTM.ai is the culmination of our public journey—from lecture transcription to a full-fledged personal knowledge assistant. Get early access to shape this next generation of memory-first tools.

Gone are the days of a single textarea for quick text snippets on your local Wi-Fi. With c0py.me 2.0, we’ve graduated to a full-fledged, server-less sharing platform—secure, anonymous, and lightning fast. Whether it’s code, images, documents, or voice notes, you can now share any payload directly between devices using end-to-end encrypted P2P connections.

What’s Changed

1. Brand Pillars:

   • Private: Zero servers. Zero traces.

   • P2P: WebRTC mesh delivers direct device-to-device transfers.

   • Instant: Real-time sharing with live progress feedback.

2. Expanded Scope:

   • From plain text → full files, folders, and streams.

   • From single “Wi-Fi room” → three distinct “worlds” for every use case.

3. Delightful UX:

   • World Selector (“Jungle,” “Room,” “Family”) up top.

   • Animated Cub Mascot showing live speed & ETA.

   • Connection Authorization modal for secure approvals.

4. Open-Source Commitment:

   • MIT-licensed on GitHub, welcoming community plugins and contributions.

How It Works

1. Choose Your World

   

   • Jungle: Public, global namespace.

   • Room: Private, code-based invites.

   • Family: Auto-discover peers on the same Wi-Fi.

2. Select & Send

   

   • Pick text snippets, files, folders, or media.

   • Click “Share” and our cub springs into action.

3. P2P Transfer

   

   • WebRTC datachannels carry your data.

   • End-to-end encryption ensures privacy.

   • Live progress and time estimates from the cub.

4. Transfer Complete

   

Who’s It For

• Hackathon Warriors
  Instant code or asset sharing when every second counts.

• Remote & Hybrid Teams
  Collaborate securely without VPNs or cloud storage.

• Friends & Family
  Send photos, videos, or shopping lists—no installs, no accounts.

• Privacy-Minded Users
  Keep your data off third-party servers and in your own hands.

Try It in 5 Seconds

1. Visit c0py.me

2. Choose your World

3. Paste or drop your payload

4. Click Share

5. Watch it appear instantly on other devices

No sign-ups. No servers. Just pure, peer-to-peer sharing.

Support Us on GitHub

c0py.me is fully open-source under MIT. ⭐️ Star the repo, submit issues, and contribute features:
github.com/sanath1599/c0py.me

Checkout of c0py.me and Start Sharing

Your feedback drives the next wave of features—join us in shaping the future of private, peer-to-peer sharing!

Say hello to c0py.me — the fastest way to share text across devices on the same Wi-Fi network. No accounts. No custom links. Just paste and go.

What Is c0py.me?

c0py.me is a local-first text-sharing tool. Open the site in your browser, paste what you want to share, hit “Share to Network,” and anyone else on the same Wi-Fi visiting c0py.me will instantly see it.

Perfect for hackathons, classrooms, or anywhere you’re working side-by-side and need instant collaboration.

Key Features

• No Sign-Ups or Installs
  No login, no setup—just visit c0py.me and start sharing right away.

• Instant Peer Visibility
  Share something and it pops up on everyone else's screen in real time. Great for code snippets, ideas, or tasks.

• Minimal, Focused UI
  No clutter. Just a clean textarea, a “Share to Network” button, and a real-time feed of what’s been shared.

• Dark & Light Mode
  Automatically detects your system theme. Easy on the eyes day or night, with a manual toggle if you want to switch it up.

Who’s It For?

• Hackathon Teams
  When the clock’s ticking, and you just want to share that one line of code or JSON payload—c0py.me makes it effortless.

• Classrooms, Workplace & Study Groups
  Teachers can share example problems or notes to everyone’s device in seconds. Students can collaborate without needing shared docs or messy group chats.

• Home Networks
  Need to send a grocery list or a quick message between family devices? Open c0py.me and everyone’s on the same page—literally.

Try It in 5 Seconds

1. Go to c0py.me

2. Paste or type something

3. Click “Share to Network”

4. Anyone else on the same Wi-Fi who opens c0py.me will see it instantly

No copy-paste links. No refreshing. Just pure, instant sharing.

What’s Coming Next

We’re just getting started. Soon, you’ll be able to:

• Set auto-expiry times on snippets

• Render Markdown and styled notes

• View snippet history locally

• And lots more tiny features to make text sharing even smoother

Support Us on Product Hunt!

We’ve launched on Product Hunt and would love your support. If you’ve ever fumbled with pastebins, shared links that didn’t load, or just wanted something that works instantly, check us out and give us a shout.

Visit our Product Hunt page https://www.producthunt.com/products/c0py-me

Their process for collecting feedback was painfully analog:

Distribute printed surveys.
Students handwrite their responses.
Volunteers manually enter data into spreadsheets.
Occasionally, mistakes creep in.
Always, it takes too much time.

So we asked the obvious question: Can AI help?

Why AI Wasn’t the Best Answer

Like most teams at the hackathon, we started with modern LLMs — GPT-4, Claude, Gemini — to interpret scanned forms. The results?

• Text fields: surprisingly accurate.

• Checkboxes: 40–60% failure rate, even with top-tier models.

• Cost: way too high for a nonprofit running on limited funds.

We realized quickly that no matter how sophisticated the AI, checkbox detection was too flaky — and definitely not budget-friendly.

So We Did the Unthinkable:

We Chose to Be Intelligent Instead

Instead of brute-forcing AI into a problem it wasn’t designed to solve, we designed around it.

We built SnapScan — a complete survey automation system that works without needing advanced AI for every input. Here's how it works:

SnapScan: Our Solution

1. Custom Form Generator

We built a tool that lets volunteers recreate RIT’s paper forms — preserving the layout and structure, but also adding two major upgrades:

• Exact box coordinate mapping (crucial for visual detection)

• A unique QR code to tag each form to the right spreadsheet

2. Scan and Detect

Once forms are filled and scanned:

• The QR code tells the system which questions and spreadsheet to sync with

• OpenCV checks for checkbox marks using pixel-perfect box mapping

• OCR handles the occasional handwritten free-text fields

3. Auto-Sync to Google Sheets

Every response is instantly logged into a shared spreadsheet — no sorting, no manual entry, no fuss.

A Better Demo Than AI

Here’s how we introduced it at the hackathon:

"This is the form RIT currently uses — built in Word. Here’s what it looks like in our system. Same format, but now there’s a QR code."
"Alberto — our fictional RIT volunteer — prints and distributes the forms. Once they’re filled out, he uploads all scanned forms to a Google Drive folder."
"SnapScan reads the QR code, detects the checkboxes, extracts the handwriting, and updates the spreadsheet. All automatically."

Why It Worked

• 100% checkbox accuracy thanks to custom layout and OpenCV

• Zero per-form AI costs — a huge win for nonprofits

• Fully automated pipeline — from scan to sheet

• Volunteer-friendly — no training needed, no tech knowledge required

We didn’t win the hackathon.
We didn’t use the flashiest LLM stack.
We didn’t even qualify under the "AI requirement" strictly.

But we built something that actually works — accurately, affordably, and at scale — for a nonprofit that truly needed it.

And sometimes, that’s worth more than a trophy.

The Team:

1. Sanath Swaroop Mulky

2. Aditi Dani

3. Manav Chandani

4. Prithvi Elancherran

5. Armin Foroughi

The Tech Stack:

• OpenCV (checkbox detection)

• pytesseract OCR(text extraction)

• React + Firebase (frontend & auth)

• Google Drive + Sheets API (storage & sync)

• Node.js (backend)

Want to Try SnapScan or Contribute?

We're exploring open-sourcing the tool for other nonprofits.
Leave a comment or DM if you're interested in collaborating or piloting it with your organization.

CANT.study now supports YouTube video inputs.

This update opens up a new world of learning possibilities by allowing students to extract meaningful notes, summaries, and transcripts from educational videos with zero manual effort.

What’s New

YouTube Link Support

Paste any public YouTube video URL into CANT.study, and our system will fetch the content and begin processing it just like a lecture recording.

Automatic Transcription and Summarization

CANT.study transcribes the spoken content in the video, summarizes it into concise points, and presents it as an organized, study-friendly format.

Search Across Video Content

Once processed, you can search the transcript and summary to find specific concepts, keywords, or explanations—without having to rewatch the video.

Unified Note Management

Whether you’re using recordings, audio uploads, or YouTube content, all notes live in one place. Organized, searchable, and ready whenever you need them.

Use Cases This Unlocks

• YouTube-Based Study Sessions
  Turn educational videos into study notes you can quickly revise, search, or export.

• Exam Prep From Online Resources
  Summarize tutorial videos the night before an exam to focus on the important bits instead of rewatching everything.

• Accessibility
  For students who prefer written content or need transcripts due to hearing impairments, YouTube videos now become equally usable learning material.

• Second Language Support
  Non-native speakers can break down complex spoken content into simplified summaries, improving comprehension and retention.

How to Use It

1. Visit CANT.study

2. Paste a YouTube video link

3. Wait a few moments while we process the content

4. View the transcript, summary, key highlights, and timestamps

5. Save your notes, search through them, or export them as needed

What’s Coming Next

We’re already working on the next set of enhancements, including:

• Support for YouTube playlists

• Unlisted video support

• PDF and Notion-style export

• AI-generated flashcards from video content

• Collaborative annotation features

Join the Journey

If you’ve been using YouTube as a learning tool, CANT.study now makes that process structured and efficient. No more pausing, rewinding, or manually jotting down notes.

Visit us on Product Hunt, try out the new feature, and let us know what you think. Your feedback drives what we build next.

https://www.producthunt.com/products/cant

What Is Build Night?

• Live, in public: Every feature release, bug fix, and design tweak is published here first.

• User-driven: We’ll prioritize and prototype based on your feedback—no more guesswork.

• Weekly updates: Tune in each Tuesday evening for release notes, pipeline glimpses, and roadmap shifts.

First Demo: CANT.study Feature Walkthrough

To launch Build Night, we’re starting with the CANT.study → wehelpyou.study demo session itself.

Highlights:

1. Start & Stop Recording with one click – 30 s audio chunks keep things smooth.

2. Context Correction Layer – NVIDIA Canary transcripts meet slide titles & jargon.

3. Iterative Summarization – Chunk-by-chunk summaries refined into one cohesive document.

4. 24-Hour Note Retention – Structured notes live for a day before auto-purge.

5. Observability Built-In – Langfuse traces + Elasticsearch log streaming for instant debugging.

Under the Hood: Architecture Snapshot

Every Build Night post will peel back a different layer of the stack. For tonight’s kickoff:

• Frontend: React + Tailwind UI

• API Layer: Node.js/Express with JWT auth & Langfuse integration

• Transcription: NVIDIA Canary → Context Correction Layer

• Summarization: Llama 3 8B-Instruct via chunk-iterate pipeline

• Observability: Langfuse tracing + Elasticsearch log streaming

How You Can Join In

1. Try the Demo: Head to wehelpyou.study, start a session, and let us know what you love (or what needs work!).

2. Submit Feedback: Use the in-app “Feedback” button or drop a comment below this post.

3. Vote Features: Each build night, we’ll open a poll—cast your vote for the next major feature.

4. Follow the Series: Bookmark this blog; every Thursday evening we’ll post release notes, technical deep dives, and roadmap updates.

What’s Next on the Pipeline

• Based on the feedback from CANT.study, we’re kicking off a fresh experiment: building a generic note-taking platform in public, designed from the ground up with CANT.study’s lessons baked in. If you’ve ever used Google Keep, Apple Notes, or any other note app, this will feel familiar—but supercharged by GenAI.

  • Open Releases: Every build version will drop publicly, complete with changelogs on improvements and upcoming work.

  • Feature-By-Request: You tell us what matters most; we’ll scope, build, and prioritize based on your suggestions.

  • Real-Time Feedback: Test each release as it lands, share your thoughts, and watch us adapt.

Stay tuned for our first full “Build Night” update next Tuesday.

Why can’t note‑taking be automated, reliable, and context‑aware?

That question became CANT — the Context‑Aware Note Taker. (http://cant.study/)

From Manual Notes to Multimodal Intelligence

CANT’s earliest prototype hinged on three technical insights:

1. Context Correction Layer
   Raw audio is first transcribed by NVIDIA Canary. A Context Correction Layer then aligns jargon, acronyms, and speaker disfluencies with the instructor’s actual slides and course materials, transforming transcripts into task‑ready text.

2. Iterative Chunk Summarization
   Lectures are streamed in ~10 k‑token chunks. Each chunk is summarized, then adjacent summaries are recursively refined to build a cohesive document—reducing LLM hallucinations and keeping sections tight and well‑labeled.

3. 24‑Hour Retention Window
   To balance study needs with privacy, only the generated structured notes are retained on the server after the first 24 hours. The system performs an auto‑purge unless a student explicitly opts to archive them.

Design Decisions & Why They Won

A (Very) Brief Tour of the Deployment Pipeline

1. Frontend – React 18 + Tailwind. A single “Start Session” button streams 30 s audio chunks and visualizes progress.

2. API Layer (Node.js + Express) – Handles JWT auth, writes Langfuse traces, handles other business logic.

3. Sandbox Container

   • Speech: NVIDIA Canary

   • Context Parser: OCR for slides/PDFs

   • LLM: Llama 3 8B‑Instruct‑128k behind an Nginx reverse proxy

4. Storage – MongoDB for transcripts & structured notes (ephemeral collections respect the 24‑hour policy).

5. CI/CD – GitHub Actions → Docker Buildx → zero‑downtime blue‑green deploys on Linode’s dedicated GPU cloud.

Launch Day: 30 April 2025 — Capstone Poster & Public Release

We unveiled CANT during the RIT Data Science Capstone poster session on 30 April 2025 and simultaneously opened public access:

First‑week impact

• 42 new registered users

• 100 + unique visitors

• 8 + hours of audio captured

• 14 structured note sets generated

Improvements and Results

What’s Next?

1. Federated Learning
   Train the Context Correction Layer on‑device so each cohort’s jargon improves future transcripts—without centralizing raw data.

2. Edge Deployment using Service Workers
   Packaging the full pipeline for offline field trips and patchy Wi‑Fi environments.

3. Open‑Source Modules
   Releasing the chunk‑iterative summarizer, Context Aware ASR Correction so researchers can plug in custom LLMs.

Thank you for following our journey from sleepy lecture halls to an AI‑powered accessibility platform. Have feedback or want to contribute? Visit cant.study—because when you CANT.study, WEHELPYOU.study.

Email: gmail@sanathswaroop.com

Contact: +1 (585)-565-2567

Choosing the “Humanity Softlanding” Track

From the opening keynote, it was clear that no single discipline holds all the answers. We chose the Humanity Softlanding track, which called for a permissionless, bias‑resistant network to collect, verify, and reward UAP observations on‑chain. Our guiding principles:

• Open Contribution: Anyone—satellite operators, backyard observers, or academic teams—should be able to feed data into the system without gatekeepers.

• Decentralized Verification: Misinformation is rampant; we built consensus‑based checks to elevate credible reports.

• On‑Chain Incentives: Contributors earn tokens tied to the quality and uniqueness of their data.

• Immutable Repository: A global ledger holds all verified UAP intelligence, accessible for future study.

By framing these goals as our solution rather than a problem statement, we steered clear of abstract challenges and focused on building a tangible proof‑of‑concept.

What We Built

Armed with a CanaKit Raspberry Pi 5 Starter Kit and a 2‑Axis Pan‑Tilt Camera Module, we deployed a network of low‑cost, programmable sensors capable of continuous sky scans. The real highlight was integrating a Pelco Thermal Imaging PTZ Camera (valued at $20,000) to simulate high‑precision observations:

1. Detection & Tracking Pipeline: Custom Python scripts on the Pi streamed thermal video to a local server, triggering snapshots whenever unusual signatures appeared.

2. Data Onboarding: Each snapshot was hashed and timestamped, then published to our smart contract on a testnet.

3. Decentralized Storage: We stored every image on IPFS for censorship‑resistant archival.

4. Reputation Engine: Contributors could upvote or challenge each sighting. Only snapshots reaching a trust‑threshold minted reward tokens.

5. Dashboard: A React front‑end visualized live feeds, recent detections, and contributor leaderboards.

By hackathon’s end, we had a fully operational demo: a decentralized UAP detection network that recognized, verified, and rewarded sightings in real time.

Mentorship and Essential Tools

We owe a huge debt to David Hooper, founder of a stealth UAP defense startup. His hands‑on guidance helped us refine our incentive model and vet our verification logic. David’s support turned our baseline design into a scalable, field‑ready system.

Additional Learnings: Discovering the Tridactyls

While most of our time was spent coding and circuit‑molding, I dove into the Biologics Track, where I stumbled upon Tridactyls.org/sfuap. The site catalogs “Tridactyls”—enigmatic, three‑toed creatures rumored to inhabit remote ecosystems. Learning about these potential lifeforms reminded me that unexplained phenomena aren’t limited to the skies; the natural world still holds secrets as profound as any UAP. That curiosity filtered back into our project: if biology can surprise us at ground level, why not in the troposphere?

The CE5 Exercise and My UAP Sighting

On the evening of April 19th at 9 PM, our team paused development to experiment with CE5 (Close Encounters of the Fifth Kind)—a meditation‑based protocol for human‑initiated contact. Skeptical but curious, I followed the guided visualization. We observed an object in the sky—what we later confirmed as a UAP. The object moved in ways that defied conventional explanations, and although we captured clear optical images, we were unable to record its thermal signature. We uploaded those optical snapshots to IPFS and validated them on‑chain. Witnessing a live UAP during a CE5 session was both surreal and validating—proof that our network could bridge human intention, observational technology, and decentralized verification.

A Surreal Setting: The USS Hornet Experience

Hosting a hackathon on the USS Hornet was unforgettable. This historic aircraft carrier not only served in World War II and Vietnam but famously recovered Apollo 11’s command module on July 24, 1969. Walking the same deck where Neil Armstrong stepped down from the capsule and made his way to the quarantine chamber was profoundly moving.

The sense of history and exploration in the air fueled our team’s ambition—reminding us that pushing into the unknown has always defined human progress.

Looking Ahead

The SF UAP Hackathon was more than a sprint; it was a proof point that collaboration, open protocols, and a bit of healthy skepticism can push the envelope on UAP truth. As I integrate lessons learned into my ongoing research, I’m excited to explore:

• Edge AI: Deploying on‑device inference to flag anomalies without constant server connectivity.

• Cross‑Discipline Data Fusion: Merging biosensor, acoustic, and radio‑frequency inputs alongside thermal imaging.

• Broader Community Engagement: Incentivizing amateur astronomers and citizen scientists through gamified discovery.

Standing on the Hornet’s deck, I felt we were at the dawn of a new era—one where transparency, technology, and collective curiosity illuminate the unknown.

1. Why AI Computation Matters

When we talk about AI, most people envision chatbots or recommendation engines. But under the hood, these systems often need to perform intense mathematical operations. Whether it’s multiplying large numbers, factoring gargantuan integers, or evaluating complex expressions, how an AI performs these tasks reveals much about its design philosophy:

• Fast, Tool-Assisted Computation: Calls upon specialized libraries or code runners for near-instant answers.

• Manual, Step-by-Step Explanation: Emulates human reasoning, typically slower but offers transparency and deeper insight into each step.

2. The Multiplication Test

Our first example involved a seemingly straightforward arithmetic query:

Calculate 25665566*6778765556

ChatGPT’s Instant Approach

result = 25665566 * 6778765556
result

173980854776044696

• The Strategy: Called a built-in “code runner” with a single Python snippet to multiply these large integers.

• The Result: A near-immediate output.

• The “Why?”: It recognized the task was purely computational and delegated it to a reliable tool.

Deepseek’s & Grok Methodical Route

• The Strategy: Simulated each step of long multiplication—similar to how you might solve it by hand, carrying digits and forming partial sums.

• The Result: Accurate, but took a notable amount of time.

• The “Why?”: Focused on clarity and a breakdown of logic at each phase, sacrificing speed for a teaching-like demonstration.

3. The Factorization Challenge

Soon after, we posed a tougher problem: factorizing a massive integer:

Prompt: Factorize 987654321987654321

Output :

$$987654321987654321=3^2 ×7×11×13×17^2 ×19×52579×379721$$

ChatGPT’s Swift Response

import sympy

num = 987654321987654321
factors = sympy.factorint(num)
factors

{3: 2, 7: 1, 11: 1, 13: 1, 17: 2, 19: 1, 52579: 1, 379721: 1}

• Tool Used: A code snippet employing the sympy library in Python.

• Time Taken: Just a couple of seconds—an immediate resolution of prime factors.

• Key Insight: Similar to how advanced communication protocols drastically improve throughput, specialized libraries handle complex math in a fraction of the time.

Deepseek’s Longer Journey

• Method: Gradual, possibly trial-division or more stepwise primality checks.

• Time Taken: 298 seconds—nearly five minutes.

• Why It Matters: Though it arrived at the same factorization, the approach highlights a commitment to manual or semi-manual problem-solving.

Final Output:

$$\boxed{3^2 \times 7 \times 11 \times 13 \times 17^2 \times 19 \times 52579 \times 379721}$$

4. Fast vs. Thorough: A Tale of Two Approaches

Whether it’s the multiplication or factorization scenario, the contrast stands out:

Tool-Based Calculation

• Pros: Lightning speed, reliable results, minimal chance of slip-ups.

• Cons: Limited transparency; the AI just “knows” the final answer without showing each step.

Manual “Thinking”

• Pros: Explains every detail, ideal for teaching and verifying each arithmetic operation.

• Cons: Time-consuming, higher risk of compounding errors if a single step is off.

5. The Final Word: Matching Tools to Tasks

Much like choosing RabbitMQ or gRPC for the right use case in microservices, deciding between tool-based or stepwise AI reasoning depends on your goals:

• If you value speed and reliability— A tool based solution is more effective

• If you need explanation and clarity—embrace the methodical, step-by-step breakdown.

Both approaches have their place, and both can produce the correct result. The key is understanding which strategy suits your scenario. When seconds matter, harness specialized libraries. When teaching or diagnosis is the main objective, a thorough, human-like walkthrough might be best.

The RESTful Dilemma

Imagine an office where every department must wait on a single phone line to get the information they need. That’s what REST felt like when our microservices had to engage in synchronous, tightly coupled exchanges. Each service call was like placing a call on that single line—if one department (or service) slowed down, the whole operation lagged behind.

• High Overhead and Latency:
  While human-readable, JSON is inherently verbose. The constant back-and-forth of large payloads led to unnecessary network chatter and increased latency.

• Tight Coupling and Cascading Failures:
  One unresponsive service could trigger a domino effect, impacting the reliability of the entire system.

• Versioning Challenges:
  Maintaining backward compatibility became an ongoing struggle as individual services evolved, often turning routine updates into a logistical nightmare.

These issues were not just theoretical. They impacted real-world systems, making REST a less-than-ideal choice for modern, high-demand applications.

The Power of Asynchronous Messaging: A Lesson from NPCI

My experience at the National Payments Corporation of India (NPCI) taught me firsthand why REST was not a viable option for certain scenarios. We were developing a high-transaction payments application that had to handle an incredibly high TPS (transactions per second). The synchronous nature of REST was a bottleneck—a recipe for delays and failures under heavy load.

To address this, we chose RabbitMQ for inter-service communication. By embracing asynchronous messaging, our services could decouple their interactions. One service would drop a message into a queue and move on, while another would pick it up and process it at its own pace.

• Handled High TPS Gracefully:
  The message queuing system absorbed the burst of transactions, ensuring that no single service became overwhelmed.

• Enhanced Resilience:
  Even if one component experienced downtime, the messages would patiently wait in the queue until processing could resume, eliminating the risk of cascading failures.

• Improved Scalability:
  Decoupled services meant that each could scale independently, without the pressure of synchronous dependencies.

In our payments application, RabbitMQ not only provided the necessary throughput but also delivered the robustness required for a mission-critical financial system—a clear testament to why REST was not the right tool for this job.

A New Chapter Begins: Embracing gRPC for Microservices

While asynchronous messaging solved many of our challenges at NPCI, there were other scenarios where we needed rapid, low-latency communication between services. While working at StaTwig, I embarked on an exciting proof-of-concept that leveraged gRPC for inter-service communication among our user, shipment, orders, and inventory services.

Why gRPC Transformed Our Communication

• Low Latency and High Performance:
  gRPC’s use of HTTP/2 and binary serialization (via Protocol Buffers) meant that messages were not only smaller but also faster to transmit. This dramatically reduced the communication delays that were all too common with REST.

• Streaming and Real-Time Data:
  With gRPC, we could implement bi-directional streaming. This was a game-changer for services that required continuous updates—imagine a real-time dashboard that never missed a beat.

• Clear and Rigid Contracts:
  The strict API contracts enforced by gRPC ensured that every service knew exactly what to expect. This clarity reduced errors and made maintenance significantly easier.

My PoC at StaTwig revealed measurable improvements: reduced latency, more efficient data handling, and a smoother overall user experience. It demonstrated that for scenarios demanding immediate, interactive communication, gRPC was far superior to the traditional REST approach.

The Final Word: Choosing the Right Tool for the Job

Both RabbitMQ and gRPC represent significant advances over REST when it comes to building modern microservice architectures. They aren’t direct competitors but rather complementary tools, each addressing different communication challenges:

• RabbitMQ is ideal for high-throughput, asynchronous environments where resilience and decoupling are paramount. My experience at NPCI proved that when every millisecond counts and scalability is a must, asynchronous messaging is the way forward.

• gRPC excels in scenarios that demand low latency and real-time interactions. At StaTwig, our PoC highlighted how gRPC could streamline communications between critical services, reducing delays and bolstering performance.

In our journey as architects and developers, the real art lies in choosing the right tool for the task at hand. Embracing RabbitMQ and gRPC has allowed us to build systems that not only meet today’s demands but also scale gracefully into the future.