Forem: Devang Tomar

The Secret Cost of Microservices: Why Your ‘Scalable’ Architecture is Draining Engineering Morale…

Devang Tomar — Sun, 06 Apr 2025 08:42:17 +0000

The Secret Cost of Microservices: Why Your ‘Scalable’ Architecture is Draining Engineering Morale 😓

The Hidden Human Toll of Distributed Systems

🔄 “We migrated to microservices for agility!”

📈 “Our system scales infinitely now!”

⚙️ “Every team owns their services independently!”

Then why is your engineering team burned out and your velocity slowing down?

After working with dozens of companies that adopted microservices, I’ve discovered an uncomfortable truth: Most microservice implementations create more problems than they solve. Here’s how your “modern” architecture might be sabotaging your team.

1. The Myth of Independent Development

The Promise vs Reality

Promised BenefitActual Outcome”Teams can deploy independently””We need 5 services to release one feature””No more coordination!””Daily cross-team syncs for API changes””Faster iteration!””Spend 80% time debugging distributed systems”

Case Study: A mid-sized company adopted microservices and saw:

40% increase in deployment frequency…
But 3x longer feature development cycles due to coordination overhead

2. The 5 Silent Productivity Killers

🕳️ 1. Distributed Debugging Hell

Traces spread across 5 systems
“It works in test but fails in prod” becomes 10x harder
Engineers need to understand 15 services to fix one bug

📉 2. The Testing Illusion

100% test coverage on each service…
But zero tests for cross-service workflows
“We didn’t realize Service A would break Service B’s cache”

🔄 3. Deployment Synchronization

“Independent deployments” require careful orchestration
Feature flags become a distributed system themselves
Rollbacks now require coordinated multi-service efforts

📊 4. Observability Overload

30 dashboards but no unified view
Alerts fire constantly from downstream services
“Is this our problem or someone else’s?”

💸 5. The Talent Tax

New engineers take 6 months to become productive
Senior devs spend all time mentoring instead of coding
Constant context switching destroys deep work

3. When Microservices Make Sense (And When They Don’t)

✅ Good Candidates

Clear domain boundaries (payment vs inventory)
True scale needs (100k+ RPS)
Mature platform/SRE team

❌ Bad Candidates

Small teams (< 15 engineers)
Rapidly evolving product
No existing monolith problems

Rule of Thumb: If you can’t draw your service boundaries on a napkin without ambiguity, you’re not ready.

4. The Modest Alternative: Modular Monoliths

The Architecture Everyone Forgot

Single deployable unit
Clear internal modules
Shared database with bounded contexts

Benefits:

90% of microservice advantages
10% of the complexity
Works beautifully for 80% of companies

Case Study: A team migrated from 22 microservices to a modular monolith and saw:

60% reduction in production incidents
2x faster feature development
New engineers productive in days instead of months

5. The Microservices Litmus Test

Ask your team:

Can most engineers name all our services and their purposes?
Do we regularly deploy services independently?
Is cross-service coordination <10% of our time?
Can new hires ship to prod in their first week?

If you answered “no” to any, you’re paying the microservices tax without getting the benefits.

Final Thought: Architecture Should Serve People, Not Vice Versa

The best architecture is the simplest one that solves your actual problems — not the one that looks best on an engineering blog.

💬 Has your team fallen into the microservices trap? What architecture lessons have you learned the hard way? Let’s discuss!

How to Create Kubernetes CRDs Using Golang and Master Controller Programming ️

Devang Tomar — Sat, 22 Feb 2025 11:15:37 +0000

Kubernetes has revolutionized the way we manage containerized applications, but what happens when you need to extend its capabilities to fit your unique use case? Enter Custom Resource Definitions (CRDs) and Controllers! With these powerful tools, you can define your own resources and automate their management in Kubernetes. 🌟

In this article, we’ll explore how to create Kubernetes CRDs using Golang and dive into the world of controller programming with the Watcher-Informer model. Whether you’re building a custom operator or extending Kubernetes for your organization, this guide will help you get started. Let’s dive in! 💻

🤔 Why Create Custom Resources and Controllers?

Before we jump into the how, let’s talk about the why. Here are a few reasons you might want to create CRDs and controllers:

Custom Workflows : You need to manage resources that Kubernetes doesn’t natively support.
Automation : You want to automate complex tasks like provisioning, scaling, or healing.
Extending Kubernetes : You’re building a platform or tool that integrates deeply with Kubernetes.

If any of these resonate with you, it’s time to roll up your sleeves and start building! 🛠️

🧰 What You’ll Need

Before we begin, make sure you have the following tools installed:

Go (Golang): We’ll use Go to write our CRD and controller. Install it from golang.org.
Kubebuilder or Operator SDK : These frameworks simplify the process of building Kubernetes operators. Install one of them.
Kubernetes Cluster : You’ll need a cluster to test your CRD and controller. Minikube or Kind are great for local development.
kubectl : The Kubernetes CLI tool for interacting with your cluster.

🚀 Step 1: Define Your Custom Resource (CRD)

Let’s create a CRD for a “Widget” resource.

Scaffold Your Project : Use Kubebuilder to set up your project.

kubebuilder init --domain mydomain.com --repo github.com/yourusername/widget-operator  
kubebuilder create api --group widgets --version v1 --kind Widget

This generates the files you need for your CRD and controller.

2. Define the Widget Schema :

Open api/v1/widget_types.go and define your Widget resource.

package v1  

import (  
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"  
)  

// WidgetSpec defines the desired state of Widget  
type WidgetSpec struct {  
    Name string `json:"name"`  
    Description string `json:"description,omitempty"`  
    Replicas int32 `json:"replicas"`  
}  

// WidgetStatus defines the observed state of Widget  
type WidgetStatus struct {  
    AvailableReplicas int32 `json:"availableReplicas"`  
}  

//+kubebuilder:object:root=true  
//+kubebuilder:subresource:status  

// Widget is the Schema for the widgets API  
type Widget struct {  
    metav1.TypeMeta `json:",inline"`  
    metav1.ObjectMeta `json:"metadata,omitempty"`  

    Spec WidgetSpec `json:"spec,omitempty"`  
    Status WidgetStatus `json:"status,omitempty"`  
}  

//+kubebuilder:object:root=true  

// WidgetList contains a list of Widget  
type WidgetList struct {  
    metav1.TypeMeta `json:",inline"`  
    metav1.ListMeta `json:"metadata,omitempty"`  
    Items []Widget `json:"items"`  
}  

func init() {  
    SchemeBuilder.Register(&Widget{}, &WidgetList{})  
}

Generate and Apply the CRD : Run these commands to generate and apply your CRD.

make manifests  
kubectl apply -f config/crd/bases/

Boom! Your CRD is now live in the cluster. 🎉

🛠️ Step 2: Build the Controller

Now, let’s build the controller to manage your Widgets.

Understand the Watcher-Informer Model :

Watcher : Watches for changes to resources. 👀
Informer : Caches resource state and triggers events. 🤖

2. Implement the Reconcile Loop :

Open controllers/widget_controller.go and add your logic.

package controllers  

import (  
    "context"  
    "fmt"  

    "github.com/go-logr/logr"  
    "k8s.io/apimachinery/pkg/runtime"  
    ctrl "sigs.k8s.io/controller-runtime"  
    "sigs.k8s.io/controller-runtime/pkg/client"  

    widgetv1 "github.com/yourusername/widget-operator/api/v1"  
)  

// WidgetReconciler reconciles a Widget object  
type WidgetReconciler struct {  
    client.Client  
    Log logr.Logger  
    Scheme *runtime.Scheme  
}  

func (r *WidgetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {  
    log := r.Log.WithValues("widget", req.NamespacedName)  

    // Fetch the Widget  
    var widget widgetv1.Widget  
    if err := r.Get(ctx, req.NamespacedName, &widget); err != nil {  
        return ctrl.Result{}, client.IgnoreNotFound(err)  
    }  

    // Your logic here  
    log.Info("Reconciling Widget", "name", widget.Name)  
    fmt.Printf("Widget Spec: %+v\n", widget.Spec)  

    // Update status  
    widget.Status.AvailableReplicas = widget.Spec.Replicas  
    if err := r.Status().Update(ctx, &widget); err != nil {  
        return ctrl.Result{}, err  
    }  

    return ctrl.Result{}, nil  
}  

func (r *WidgetReconciler) SetupWithManager(mgr ctrl.Manager) error {  
    return ctrl.NewControllerManagedBy(mgr).  
        For(&widgetv1.Widget{}).  
        Complete(r)  
}

Run the Controller : Start your controller locally to test it.

make run

🧪 Step 3: Test Your CRD and Controller

Create a Widget Resource : Create a widget-example.yaml file:

apiVersion: widgets.mydomain.com/v1  
kind: Widget  
metadata:  
  name: example-widget  
spec:  
  name: "example-widget"  
  description: "This is an example widget."  
  replicas: 3

Apply the Resource : Use kubectl to apply it.

kubectl apply -f widget-example.yaml

Check the Logs : Watch your controller logs to see the magic happen! ✨

🚀 Step 4: Deploy Your Controller

Once it works locally, deploy it to your cluster.

Build and Push the Docker Image :

make docker-build docker-push IMG=<your-docker-image>

Deploy the Controller

make deploy IMG=<your-docker-image>

🎉 You Did It!

You’ve just:

✅ Created a Custom Resource Definition (CRD)

✅ Built a Controller using the Watcher-Informer model

✅ Automated your custom resources like a pro! 🚀

Now go forth and extend Kubernetes to fit YOUR needs! 🌟

Interacting with the Kubernetes API: From kubectl to Custom Clients

Devang Tomar — Sat, 08 Feb 2025 10:40:22 +0000

Kubernetes is like the brain of your cloud-native applications, managing everything from deploying workloads to keeping them healthy. But how does it actually work behind the scenes? That’s where the Kubernetes API Server comes in!

If you’ve ever run kubectl get pods, congratulations—you’ve already used the API server! But there’s a whole world beyond just kubectl—from direct API calls to writing custom clients and controllers. Let’s dive in and explore how you can talk to Kubernetes like a pro!

🤖 Meet the Kubernetes API Server

The Kubernetes API Server (kube-apiserver) is the gateway to all things Kubernetes. It’s like the receptionist at a busy office—handling requests, checking permissions, and making sure everything runs smoothly.

Here’s what happens when you interact with Kubernetes:

You make a request (e.g., create a pod, list services).
The API Server checks permissions (using authentication and authorization).
It validates and processes the request (possibly modifying it via admission controllers).
The new state is stored in etcd (the brain of Kubernetes!).
Controllers and schedulers react to ensure everything is running as expected.

Everything in Kubernetes is an API call under the hood — so mastering the API is key!

🛠️ Talking to Kubernetes with kubectl

The simplest way to interact with the Kubernetes API is via kubectl. It's a friendly wrapper around API requests. Let’s see some fun tricks!

Get Raw API Data

kubectl get pods -o json

This is just a fancy way of saying “Hey Kubernetes, show me everything about my pods” in JSON format.

Explore API Endpoints

Want to see what resources are available? Try this:

kubectl api-resources

You’ll get a list of all the things Kubernetes can manage — from pods to secrets to custom resources!

Making Direct API Calls

If you’re feeling adventurous, try accessing the API directly:

kubectl proxy --port=8080
curl http://localhost:8080/api/v1/nodes

This bypasses kubectl and talks to Kubernetes raw and unfiltered.

👨‍💻 Building Your Own Kubernetes API Client

Want to go beyond kubectl? Let’s build a custom Go client to interact with Kubernetes directly!

Install client-go

First, install the official Kubernetes Go client:

go get k8s.io/client-go@latest

Connecting to Your Cluster

Here’s a simple Go program that lists all pods in the default namespace:

package main

import (
 "context"
 "fmt"
 "k8s.io/client-go/kubernetes"
 "k8s.io/client-go/rest"
 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func main() {
 config, err := rest.InClusterConfig()
 if err != nil {
  panic(err.Error())
 }

 clientset, err := kubernetes.NewForConfig(config)
 if err != nil {
  panic(err.Error())
 }

 pods, err := clientset.CoreV1().Pods("default").List(context.TODO(), metav1.ListOptions{})
 if err != nil {
  panic(err.Error())
 }

 for _, pod := range pods.Items {
  fmt.Println("Pod Name:", pod.Name)
 }
}

This will list all pods in your cluster programmatically. Now, you’re officially a Kubernetes hacker! 🚀

🌟 Advanced Fun: Custom Controllers and CRDs

Want to teach Kubernetes new tricks? You can create your own Custom Resource Definitions (CRDs) and build controllers to manage them automatically.

Example: Creating a New Custom Resource

Define a new Widget resource:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: widgets.example.com
spec:
  group: example.com
  names:
    kind: Widget
    plural: widgets
  scope: Namespaced
  versions:
  - name: v1
    served: true
    storage: true

Now Kubernetes knows what a Widget is! Next, let’s create a controller to manage them.

Running the Custom Controller

Once your custom controller is running, you can interact with it just like built-in Kubernetes resources!

Create a Widget Instance

kubectl apply -f widget-crd.yaml
kubectl apply -f example-widget.yaml

Check the Custom Resource

kubectl get widgets

Describe a Specific Widget

kubectl describe widget example-widget

Your controller will make sure your widgets are always in the desired state, just like how Kubernetes keeps pods running.

🚀 Wrapping Up

Mastering the Kubernetes API unlocks endless possibilities. Whether you’re:

Using kubectl for quick commands,
Writing scripts that make direct API calls,
Building custom clients , or
Creating custom controllers to extend Kubernetes itself…

…you now have the skills to talk to Kubernetes like a pro!

🔗 Want more Kubernetes fun? Follow me for more DevOps & Cloud insights! 🚀

How to Write Your Own Terraform Provider: A Step-by-Step Guide 🛠️ ️

Devang Tomar — Fri, 31 Jan 2025 18:31:02 +0000

Terraform has become the go-to tool for infrastructure as code (IaC), enabling developers to define and provision infrastructure using a declarative configuration language. While Terraform supports a wide range of cloud providers and services out of the box, there may come a time when you need to manage a custom resource or integrate with a proprietary API. That’s where writing your own Terraform provider comes in! 🌟

In this article, we’ll walk through the process of creating your very own Terraform provider from scratch. Whether you’re managing a niche cloud service or an internal tool, this guide will help you get started. Let’s dive in! 💻

🤔 Why Write a Custom Terraform Provider?

Before we jump into the *how*, let’s talk about the *why*. Here are a few reasons you might want to create your own Terraform provider:

Custom Resources : You have a unique service or tool that isn’t supported by existing providers.
Proprietary APIs : Your organization uses internal APIs that need to be managed as infrastructure.
Extending Terraform : You want to add functionality to Terraform that aligns with your specific workflows.

If any of these resonate with you, it’s time to roll up your sleeves and start building! 🛠️

🧰 Prerequisites

Before we begin, make sure you have the following tools installed:

Go (Golang): Terraform providers are written in Go. Install it from golang.org.
Terraform : You’ll need Terraform installed to test your provider. Download it from terraform.io.
Git : For version control and managing your provider’s code.

🚀 Step 1: Set Up Your Go Environment

First, let’s set up your Go workspace. Create a new directory for your provider and initialize a Go module:

mkdir terraform-provider-myprovider
cd terraform-provider-myprovider
go mod init github.com/yourusername/terraform-provider-myprovider

This will create a go.mod file, which manages your project’s dependencies.

🛠️ Step 2: Create the Provider Skeleton

Terraform providers follow a specific structure. Start by creating the basic files and directories:

Create the main.go file: This is the entry point for your provider.

package main

import (
    "github.com/hashicorp/terraform-plugin-sdk/v2/plugin"
    "github.com/yourusername/terraform-provider-myprovider/myprovider"
)

func main() {
    plugin.Serve(&plugin.ServeOpts{
        ProviderFunc: myprovider.Provider,
    })
}

Create the provider file: In a new directory called myprovider, create a file named provider.go.

package myprovider

import (
    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

func Provider() *schema.Provider {
    return &schema.Provider{
        ResourcesMap: map[string]*schema.Resource{},
        DataSourcesMap: map[string]*schema.Resource{},
    }
}

This sets up the basic structure of your provider. Right now, it doesn’t do much, but we’ll add resources and data sources soon.

🔧 Step 3: Define Your First Resource

A Terraform provider is useless without resources. Let’s define a simple resource. For example, let’s say we’re creating a provider to manage “widgets” in a fictional API.

Create a resource file: In the myprovider directory, create a file named resource_widget.go.

package myprovider

import (
    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

func resourceWidget() *schema.Resource {
    return &schema.Resource{
        Create: resourceWidgetCreate,
        Read: resourceWidgetRead,
        Update: resourceWidgetUpdate,
        Delete: resourceWidgetDelete,

        Schema: map[string]*schema.Schema{
            "name": {
                Type: schema.TypeString,
                Required: true,
            },
            "description": {
                Type: schema.TypeString,
                Optional: true,
            },
        },
    }
}

func resourceWidgetCreate(d *schema.ResourceData, m interface{}) error {
    // Implement logic to create a widget.
    d.SetId("widget-id") // Set a dummy ID for now.
    return nil
}

func resourceWidgetRead(d *schema.ResourceData, m interface{}) error {
    // Implement logic to read a widget.
    return nil
}

func resourceWidgetUpdate(d *schema.ResourceData, m interface{}) error {
    // Implement logic to update a widget.
    return nil
}

func resourceWidgetDelete(d *schema.ResourceData, m interface{}) error {
    // Implement logic to delete a widget.
    return nil
}

func Provider() *schema.Provider {
    return &schema.Provider{
        ResourcesMap: map[string]*schema.Resource{
            "myprovider_widget": resourceWidget(),
        },
        DataSourcesMap: map[string]*schema.Resource{},
    }
}

🧪 Step 4: Test Your Provider

Now that you’ve defined a resource, it’s time to test your provider. First, build the provider:

go build -o terraform-provider-myprovider

Next, create a Terraform configuration file (main.tf) to test the provider:

provider "myprovider" {}

resource "myprovider_widget" "example" {
  name = "example-widget"
  description = "This is an example widget."
}

Finally, initialize and apply your Terraform configuration:

terraform init
terraform apply

🚀 Step 5: Publish and Share Your Provider

Once your provider is working, you can publish it to the Terraform Registry or share it with your team. To publish it:

Tag your release: Use Git to tag your release.

git tag v1.0.0
git push origin v1.0.0

Submit to the Terraform Registry: Follow the Terraform Registry documentation to publish your provider.

🎉 Congratulations! You’ve Built a Terraform Provider!

Writing a custom Terraform provider might seem daunting at first, but once you break it down into steps, it’s entirely manageable. By following this guide, you’ve learned how to:

Set up a Go project for your provider.
Define resources and data sources.
Test and publish your provider.

The $10 Data Trick That Makes AI Assistants Sound Human

Devang Tomar — Sat, 28 Dec 2024 05:51:30 +0000

AI assistants are impressive, but let’s be honest — sometimes they come across as robotic, overly formal, or downright clueless. What if I told you there’s a simple, $10 data trick that can make your AI assistant sound remarkably human, as if it’s actually paying attention to you?

Spoiler alert: It’s not about fancy models or expensive APIs. It’s about structured personalization — a small but powerful hack that turns generic responses into tailored, human-like interactions.

Let’s dive into how you can implement this trick, why it works, and how it can make your AI assistant shine.

Why AI Assistants Feel Robotic 🦾

Most AI assistants rely on massive datasets to generate responses, but these datasets are:

Generic : They don’t reflect individual user preferences.
Unstructured : The assistant can’t efficiently connect the dots between bits of information.

This means your assistant might sound smart in a general sense but fails to deliver the nuanced, personalized tone that human conversations require.

The $10 Data Trick: Structured Personalization 🤖

The trick is simple: combine unstructured natural language inputs with structured user data.

Structured data refers to information stored in organized formats like databases or spreadsheets. Think of data like:

• A user’s name , location , and preferences.

• Interaction history , such as past questions or purchases.

• Contextual metadata , like the time of day or device being used.

When paired with an LLM, this data enables the assistant to craft responses that feel personal and relevant.

How It Works 🏋🏻‍♀️

1. Collect User Data (Ethically!)

Start by gathering basic, consented information about your users. For example:

• Name

• Favorite topics (e.g., sports, technology, or travel)

• Recent interactions (e.g., last search query or support ticket)

2. Store It in a Structured Format

Use a lightweight database like SQLite or Firebase to store the data. Example:

User ID Name Last Interaction Preferred Style

001 Alice Asked about flights Casual

002 Bob Purchased a laptop Formal

3. Inject It into Prompts

When crafting prompts for your LLM, include relevant structured data.

Before:

“What are the cheapest flights available?”

After:

“Hi Alice! I found the cheapest flights from Bangalore to Paris for you. Would you like them sorted by price or duration?”

Why It Works 🤔

1. Context Makes Conversations Flow

By pulling data from a structured source, the assistant instantly becomes more aware of the user’s context. This avoids repetitive questions and creates a smoother, more intuitive experience.

2. Personalization Builds Trust

When users feel their preferences are remembered, they perceive the assistant as smarter and more reliable.

3. Structure Prevents Hallucination

Structured data anchors the AI, reducing the likelihood of generating inaccurate or overly generic responses.

Real-Life Examples 📖

1. E-Commerce:

Without personalization:

“Here are some laptops under $1,000.”

With personalization:

“Hi Bob! Based on your recent purchase, here are laptops under $1,000 that are compatible with the accessories you bought.”

2. Travel Assistants:

Without personalization:

“Flights to Paris start at $500.”

With personalization:

“Hi Alice, flights from Bangalore to Paris next Thursday start at $500. Want me to check hotel deals too?”

3. Customer Support:

Without personalization:

“How can I help you today?”

With personalization:

“Hi Alice, I see your last support request was about payment issues. Are you following up on that, or is this about something new?”

Cost Breakdown 💰

Here’s how you can implement this trick for under $10 :

Database Setup : Free options like SQLite or Firebase for small-scale projects.
Embedding API Costs : A few cents per query using OpenAI, Hugging Face, or similar services.
Time Investment : A few hours to integrate structured data into your pipeline.

That’s it. A small investment for a massive impact.

The Big Payoff 🧾

Companies that use structured personalization have seen:

• 20–40% higher customer satisfaction scores.

• 30% increase in task completion rates for AI assistants.

• Significant revenue boosts from improved user retention.

How to Get Started Today 🎬

Identify Key User Data : Decide what details are most relevant for your assistant’s purpose.
Set Up a Database : Use a simple spreadsheet or cloud database to organize and store data.
Enhance Your Prompts : Experiment with injecting structured data into your AI prompts.

Final Thoughts 💭

The human touch isn’t magic — it’s structure. By integrating structured user data into your AI assistant, you can move from cold, robotic responses to meaningful, engaging conversations. All for less than $10.

Connect with Me on Social Media

🐦 Follow me on Twitter: devangtomar7

🔗 Connect with me on LinkedIn: devangtomar

📷 Check out my Instagram: be_ayushmann

Ⓜ️ Checkout my blogs on Medium: Devang Tomar

#️⃣ Checkout my blogs on Hashnode: devangtomar

🧑‍💻 Checkout my blogs on Dev.to: devangtomar

How a Sneaky AI Hack Turned 5 Lines of Code into a $1M Search Engine Upgrade

Devang Tomar — Fri, 20 Dec 2024 05:31:33 +0000

Search engines power the world — whether it’s finding the perfect recipe, the latest tech gadget, or that obscure meme template you saw last week. But beneath their sleek search bars, many engines rely on outdated systems, leading to irrelevant results, frustrated users, and lost revenue.

What if I told you that with just 5 lines of code, you could transform your search engine into a powerhouse, increasing its efficiency and even driving $1M+ in revenue?

Let’s dive into the sneaky AI hack that’s making it possible: embedding-based searches powered by Large Language Models (LLMs).

The Problem with Traditional Search Engines 😵

Legacy search engines typically use keyword-based search. This means they match user queries to documents by looking for literal matches. Sounds simple, right? But here’s the catch:

• Synonyms trip them up: Searching for “buy running shoes” might miss results for “purchase sneakers.”

• Context goes over their head: Searching for “python tutorial” could return snake-related content instead of programming resources.

• Rigid ranking: Results are ranked by keyword frequency rather than understanding the query’s intent.

These limitations hurt user satisfaction and conversion rates — a big deal for e-commerce, content platforms, and SaaS tools.

The Sneaky Hack: Embedding-Based Searches 🕵🏻‍♂️

Enter embeddings , the secret sauce that’s supercharging search engines.

An embedding is a numerical representation of text, capturing its semantic meaning rather than just the words. For example, embeddings for “buy running shoes” and “purchase sneakers” would be close together in vector space, ensuring they’re treated as similar queries.

Here’s the crazy part: with just 5 lines of code , you can integrate embeddings into your search engine. Here’s what they do:

Convert queries and documents into embeddings.
Use vector similarity (like cosine similarity) to find the closest match.
Return results ranked by relevance , not just keywords.

The 5 Lines of Code That Changed Everything 🧑🏻‍💻

This is how simple it can be with tools like OpenAI’s API or Hugging Face:

from openai.embeddings_utils import get_embedding, cosine_similarity
query_embedding = get_embedding("buy running shoes")
results = [cosine_similarity(query_embedding, doc_embedding) for doc_embedding in documents]
sorted_results = sorted(zip(results, documents), reverse=True)

That’s it. These 5 lines connect your search query to the most relevant results based on meaning, not just keywords.

Real-Life Magic: Embeddings in Action 🪄

Here are some ways embedding-based searches are transforming industries:

1. E-Commerce: Boosting Sales

An online retailer implemented embeddings to improve product searches. Instead of relying on rigid keywords, their search engine understood user intent. For example:

• Query: “affordable wireless headphones”

• Results: Products with descriptions like “budget-friendly Bluetooth earphones.”

Result? 25% increase in sales , translating to millions in revenue.

2. Knowledge Management: Finding the Needle in the Haystack

A SaaS company used embeddings to enhance its internal knowledge base. Employees could now find relevant documentation — even when they didn’t know the exact phrasing.

Result? 50% reduction in search time , boosting productivity across teams.

3. Content Platforms: Winning the Engagement Game

A streaming platform used embeddings to deliver personalized content recommendations. If a user searched for “feel-good movies,” they’d get curated suggestions even if “feel-good” wasn’t a keyword.

Result? 30% increase in user retention.

The Cost vs. Impact Breakdown 💴

At this point, you’re probably wondering: how much does this cost?

Here’s the kicker: embedding-based searches are surprisingly affordable.

• Cost per query: APIs like OpenAI or Hugging Face charge a fraction of a cent for generating embeddings.

• Compute requirements: Vector search tools like Pinecone or Weaviate make integration seamless, even for large datasets.

Impact: Businesses report ROI in the range of 10x–100x , thanks to improved search accuracy, higher conversions, and better user retention.

Why This Hack Works So Well 🙋🏻‍♂️

Here’s why embedding-based searches are a game-changer:

Contextual Understanding: They can match “cheap hotels near me” with “budget accommodations.”
Scalability: Perfect for massive datasets with millions of entries.
Future-Proof: As LLMs improve, embeddings become even more precise.

Your $1M Upgrade Starts Here 💰

Ready to transform your search engine? Start small:

• Step 1: Use an API like OpenAI to generate embeddings.

• Step 2: Plug them into a vector database like Pinecone or FAISS.

• Step 3: Test, refine, and watch your metrics soar.

With just a few lines of code and minimal upfront investment, you could unlock the full potential of your search engine — and, who knows, maybe even drive $1M+ in value.

Connect with Me on Social Media

Why Your Chatbot Will Fail Without This One Simple Fix

Devang Tomar — Sat, 14 Dec 2024 08:59:27 +0000

Chatbots are everywhere: from your favorite shopping app to your bank’s customer service. They promise instant answers, seamless interactions, and even a little personality. But let’s be real — how many times have you found yourself screaming at a bot for being clueless about your context after just one question?

Here’s the harsh truth: most chatbots are doomed to fail. And it’s not because they lack fancy AI models or clever prompts. It’s because they don’t remember. That’s right — your chatbot’s memory (or lack thereof) is likely its Achilles’ heel.

In this article, I’ll break down why memory is the one simple fix that separates frustrating bots from truly intelligent assistants, and how you can implement it without breaking the bank.

The Memory Problem: Bots with the Attention Span of a Goldfish 🐟

Most chatbots today are stateless. This means they treat every user query in isolation, forgetting everything you said before. Imagine having a conversation like this:

You: “What’s the weather today?”

Bot: “It’s sunny in Bangalore.”

You: “And tomorrow?”

Bot: “I don’t understand. Please clarify.”

Without memory, the bot can’t connect your follow-up question, “And tomorrow?” to your previous query about the weather. The result? Frustrated users and abandoned chats.

Why Context Is King 👑

Contextual memory allows chatbots to string together a coherent conversation. Here’s why it matters:

Natural Conversations : Just like humans, chatbots need to recall what was said earlier to respond intelligently.

Example: If you ask, “What’s the cheapest flight to Delhi?” and then, “Can I book it for next Friday?”, the bot should know “it” refers to the Delhi flight.

Personalization : Memory helps bots remember user preferences.

Example: After you tell a food delivery bot, “I’m vegetarian,” it shouldn’t suggest chicken curry in the same session.

Efficiency : Repeating yourself is annoying! Memory saves users the trouble of re-explaining their needs.

The Simple Fix: Add Memory to Your Chatbot 💾

Building a chatbot with memory isn’t as hard as it sounds. Here’s how you can do it:

1. Session Memory (Short-Term)

• What it does : Remembers user inputs during a single conversation session.

• How to implement : Use tools like LangChain or Semantic Kernel to create a memory object that stores context temporarily.

• Example : A bot can keep track of your travel dates, destinations, and preferences until the chat ends.

2. Persistent Memory (Long-Term)

• What it does : Retains information across sessions for returning users.

• How to implement : Store user data securely in a database and retrieve it when they log in.

• Example : A shopping bot remembers your shoe size and preferred brands from past sessions.

3. Dynamic Memory Updates

• What it does : Continuously updates the memory based on new inputs.

• How to implement : Use models like GPT-4 with memory augmentation to refine the context dynamically.

• Example : Updating a chatbot’s knowledge base mid-conversation to include new information the user shares.

Tools to Add Memory to Your Bots 🛠️

Here are some frameworks that make it easy to embed memory into your chatbots:

• LangChain : Comes with pre-built modules for memory, making it a breeze to add context to LLM-powered bots.

• Haystack : Great for integrating conversational memory with knowledge bases.

• Redis : A blazing-fast database that can store session memory for real-time updates.

Real-World Success Stories 📖

• Alexa and Siri : Their ability to remember your name, preferences, and past interactions keeps them ahead of the curve.

• Booking.com’s Chatbot : It saves your search history to recommend relevant hotels without asking the same questions repeatedly.

• E-commerce Bots : Brands like Sephora use memory to recall your skin type and suggest personalized skincare products.

The Bottom Line 🎬

If your chatbot lacks memory, it’s like having a conversation with someone who forgets everything the moment you finish speaking. Users will get annoyed, leave, and possibly never return. Adding memory is not just a feature — it’s the foundation for making chatbots intuitive, human-like, and downright useful.

Don’t let your chatbot fail because of a goldfish brain. Fix it with memory, and watch your user satisfaction skyrocket 🚀!

Connect with Me on Social Media

Hidden Gems : 20 Lesser-Known VS Code Extensions to Boost Your Productivity

Devang Tomar — Sun, 08 Dec 2024 12:01:13 +0000

In this article, we uncover 20 hidden gems — VS Code extensions you’ve probably never heard of but absolutely need to try 👀 🚀

Photo by Chris Ried on Unsplash

Visual Studio Code (VS Code) is the go-to editor for developers worldwide, offering a treasure trove of extensions to customize and enhance your workflow. While popular tools like Prettier and Live Server often steal the spotlight, there’s a whole world of lesser-known extensions that can truly supercharge your productivity.

1. Peacock

Description: Working with multiple VS Code instances? Peacock lets you color-code your editor windows for better context switching.

Use Case: Easily identify your workspace when juggling multiple projects.

Install: Peacock

2. Code Time

Description: Gain insights into your coding habits with this productivity tracker. It integrates seamlessly with your workflow without being intrusive.

Use Case: Track your coding hours, focus time, and efficiency metrics.

Install: Code Time

3. Todo Tree

Description: Automatically find and organize your TODO, FIXME, or other comments in your project.

Use Case: Manage your tasks directly from the sidebar without losing track of them.

Install: Todo Tree

4. Polacode

Description: Need to share beautiful code snippets? Polacode generates picture-perfect images of your code in seconds.

Use Case: Create polished visuals for documentation or social media.

Install: Polacode

5. Error Lens

Description: Supercharge your debugging process by highlighting errors and warnings inline in your code.

Use Case: Avoid flipping between the problems panel and your code.

Install: Error Lens

6. GitLens

Description: A powerful extension for visualizing and navigating your Git repository.

Use Case: Explore commit history, file blame annotations, and branch comparisons effortlessly.

Install: GitLens

7. Better Comments

Description: Make your comments more readable and meaningful with color-coded categories like TODO, NOTE, and IMPORTANT.

Use Case: Collaborate effectively with teammates using well-organized comments.

Install: Better Comments

8. Quokka.js

Description: Get real-time feedback on your JavaScript and TypeScript code with this interactive playground.

Use Case: Test and debug snippets quickly without leaving your editor.

Install: Quokka.js

9. CSS Peek

Description: Navigate directly to CSS definitions in your project.

Use Case: Quickly jump between HTML elements and their corresponding CSS styles.

Install: CSS Peek

10. REST Client

Description: Test APIs without leaving VS Code. This extension is a lightweight alternative to Postman.

Use Case: Make HTTP requests directly from your editor.

Install: REST Client

11. Git Graph

Description: Visualize your Git repository’s commit graph with a simple UI.

Use Case: Understand your project’s history and branches at a glance.

Install: Git Graph

12. Bracket Pair Color DLW

Description: Assign colors to matching brackets for better readability in complex code.

Use Case: Navigate deeply nested code structures without confusion.

Install: Bracket Pair Color DLW

13. vscode-icons

Description: Add visually appealing file and folder icons to your workspace.

Use Case: Quickly identify file types at a glance.

Install: vscode-icons

14. Highlight Matching Tag

Description: Automatically highlight matching HTML and XML tags to ensure proper nesting.

Use Case: Avoid syntax errors in web development.

Install: Highlight Matching Tag

15. Bookmarks

Description: Bookmark lines of code and jump between them effortlessly.

Use Case: Navigate large codebases with ease.

Install: Bookmarks

16. Excel Viewer

Description: View and edit Excel files directly in VS Code.

Use Case: Analyze data without switching to another tool.

Install: Excel Viewer

17. Path Intellisense

Description: Autocomplete file paths in your project.

Use Case: Save time while importing or linking files.

Install: Path Intellisense

18. SQLTools

Description: A database management extension that allows you to connect to SQL databases, execute queries, and explore schemas — all within VS Code.

Use Case: Manage your backend databases without leaving your code editor.

Install: SQLTools

19. Git Blame

Description: Provides a simple interface to view git blame information directly in the VS Code editor. It shows who last modified a line of code and when, without needing to open the terminal or command line.

Use Case: Perfect for quickly tracking down the history of a specific line of code and understanding who to approach for questions regarding that section.

Install: Git Blame

20. WakaTime

Description: Track your coding activity across projects and languages.

Use Case: Gain insights into your productivity over time.

Install: WakaTime

Final Thoughts

These hidden gems are powerful yet often overlooked. Integrating them into your workflow can save you time, simplify tasks, and even make coding more enjoyable. So, go ahead and give these underrated extensions a shot!

Do you know of any other lesser-known yet awesome extensions? Share your favorites in the comments below.

Connect with Me on Social Media

Setting Up a Mac for Development: A Comprehensive Guide 🧑🏻‍💻 ‍

Devang Tomar — Sun, 24 Nov 2024 09:46:34 +0000

Photo by Emile Perron on Unsplash

Setting up a new Mac for development can be time-consuming, especially if you’re a developer who needs an efficient and tailored environment. Whether you’re setting up a work machine or a personal computer, having a checklist can save time and effort. Here’s a streamlined guide for getting your MacBook ready for development, optimized for macOS 15 (Sequoia).

Getting Started 🎬

When you turn on your Mac, the setup assistant will guide you through basic configurations like selecting your language, time zone, and Apple ID. Once done, update macOS to ensure you have the latest security patches.

Install Homebrew for App Management ☕️
Installing Essential Applications 📲
Setting Up the Shell
Custom Brew Packages and Zsh Configuration
Configuring Git
Generate SSH Keys
Tuning macOS Settings
Application-Specific Tips

Install Homebrew for App Management ☕️

Homebrew is a must-have package manager for macOS, simplifying the installation of software.

Run the following command to install Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

After installation, ensure it’s updated:

brew update

Installing Essential Applications 📲

Here’s a list of CLI tools and GUI applications you’ll likely need:

Command-Line Tools

Install these using Homebrew:

brew install git

Graphical Applications

Install these with the — cask flag:

brew install - cask \
visual-studio-code \
google-chrome \
firefox \
rectangle \
iterm2 \
docker \
discord \
slack \
spotify \
postgres \
obsidian \
todoist

Note : Do not install Node.js via Homebrew. Use nvm for better version control (details below).

Setting Up the Shell

macOS comes with zsh as the default shell. Enhance it with Oh My Zsh :

sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Add Shortcuts

Edit your ~/.zshrc file to include aliases for convenience. For example:

alias x86="env /usr/bin/arch -x86_64 /bin/zsh - login"
alias arm="env /usr/bin/arch -arm64 /bin/zsh - login"

Custom Brew Packages and Zsh Configuration

To further enhance your development environment, you can reference and use custom configurations from my personal repository.

This repository contains my curated list of brew packages , Zsh plugins , and shortcuts to optimize productivity.

Access the Repository

GitHub - devangtomar/zsh-settings: This repository is dedicated to storing and managing my custom Zsh settings and configurations ⚙️

From the repository, you can:

Get a list of Homebrew packages I frequently use.
Import my custom ~/.zshrc settings to streamline your shell experience.

Clone the repository to your local machine:

git clone https://github.com/devangtomar/zsh-settings.git

Navigate to the directory and explore the setup:

cd zsh-settings

Feel free to fork or adapt the configurations to match your workflow!

Configuring Git

Set up your Git global configuration:

touch ~/.gitconfig

Add the following content to customize Git commands:

[user]
  name = Your Name
  email = your_email@example.com
[github]
  user = username
[alias]
  a = add
  cm = commit -m
  s = status
  p = push
  co = checkout
  fp = fetch --prune --all
  l = log --oneline --decorate --graph
[push]
 autoSetupRemote = true

With the above aliases, I can run git s instead of git status, for example. It will also automatically set up your remote, so you can do git push on a branch without specifying the upstream origin.

Generate SSH Keys

Create an SSH key for authentication, Start ssh-agent and adding the key:

ssh-keygen -t ed25519 -C "your_email@example.com"
eval "$(ssh-agent -s)"
ssh-add - apple-use-keychain ~/.ssh/id_ed25519

For easier management, create an SSH config file (~/.ssh/config):

Host *
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/id_ed25519

Host myssh
  HostName example.com
  User user
  IdentityFile ~/.ssh/key.pem

Now just run the alias to connect.

ssh myssh

Tuning macOS Settings

To improve productivity, adjust these macOS settings:

Sidebar

To get the Home folder in the finder, press CMD + SHIFT + H and drag the home folder to the sidebar.

General

Make Google Chrome default browser

Dock

Automatically hide and show Dock
Show indicators for open applications

Keyboard

Key Repeat -> Fast
Delay Until Repeat -> Short
Disable “Correct spelling automatically”
Disable “Capitalize words automatically”
Disable “Add period with double-space”
Disable “Use smart quotes and dashes”

Security and Privacy

Allow apps downloaded from App Store and identified developers
Turn FileVault On (makes sure SSD is securely encrypted)

Sharing

Change computer name
Make sure all file sharing is disabled

Users & Groups

Add “Rectangle” to Login items

Defaults

A few more commands to change some defaults.

# Show Library folder
chflags nohidden ~/Library
# Show hidden files
defaults write com.apple.finder AppleShowAllFiles YES
# Show path bar
defaults write com.apple.finder ShowPathbar -bool true
# Show status bar
defaults write com.apple.finder ShowStatusBar -bool true
# Prevent left and right swipe through history in Chrome
defaults write com.google.Chrome AppleEnableSwipeNavigateWithScrolls -bool false

Application-Specific Tips

Chrome

Install uBlock Origin
Install React DevTools
Install Redux DevTools
Install Duplicate Tab Shortcut
Settings -> Set theme to “Dark”

Visual Studio Code

Press CMD + SHIFT + P and click "Install code command in PATH".

Now you can use code {file} to open any file in VSCode.

Extensions

Install Diverse Dye
Install GitLens
Install Highlight Matching Tag
Install ESLint
Install Prettier

Rectangle

Full Screen: CMD + SHIFT + ' (prevents messing with other commands)
Left Half: CMD + OPTION + LEFT
Right Half: CMD + OPTION + RIGHT

iTerm2

For some reason, iTerm2 does not let you use ⌥ + ← and → to tab through words in the terminal by default. I found this article to fix it: Use ⌥← and ⌥→ to jump forwards / backwards

Go to Profiles -> Keys:
Change ⌥← via "Send Escape Sequence" with b
Change ⌥→ via "Send Escape Sequence" with f

Conclusion

This guide is designed to provide a quick, repeatable process for setting up a Mac for development. By automating installations and configuring settings upfront, you can focus on coding and productivity rather than setup hassles.

Connect with Me on Social Media

How one line of code caused a $60 million loss 📉😓

Devang Tomar — Tue, 30 Jan 2024 18:32:43 +0000

60,000 people lost full phone service, half of AT&Ts network was down, and 500 airline flights were delayed

On January 15th, 1990, AT&Ts New Jersey operations center detected a widespread system malfunction, shown by a plethora of red warnings on their network use display.

Despite attempts to rectify the situation, the network remained compromised for 9 hours, leading to a 50% failure rate in call connections.

AT&T lost over $60 million as a result with over 60,000 of Americans left with fully disconnected phones.

Furthermore, 500 airline flights were delayed, affecting 85,000 people.

AT&Ts long-distance network was supposedly a paragon of efficiency, handling a substantial portion of the nations calls with its advanced electronic switches and signaling system. This system usually completed call routing within seconds.

However, on this day, a fault originating in a New York switch cascaded through the network. This was due to a software bug in a recent update that contained a critical bug affecting the networks 114 switches. When the New York switch reset itself and sent out signals, this bug caused a domino effect, leading to widespread network disruption.

This software patch had already gone through layers of testing without being caught. This incident was especially surprising because AT&T was known for their rigorous testing.

The Problem 😓

The root cause was traced back to a coding error in a software update implemented across the networks switches.

The error, within a C program, involved a misplaced break statement within nested conditional statements, leading to data overwrites and system resets.

The pseudocode :

while (ring receive buffer not empty 
          and side buffer not empty):

  Initialize pointer to first message in side buffer
       or ring receive buffer

  get copy of buffer

  switch (message):

    case (incoming_message):

      if (sending switch is out of service):

        if (ring write buffer is empty):

          send "in service" to status map

        else:

          break // The error was here!

        END IF

      process incoming message, set up pointers to
               optional parameters

      break
    END SWITCH


do optional parameter work

The problem:

If the ring write buffer is NOT empty, then the if statement on line 7 is skipped and the break statement on line 10 is hit instead.
However, for the program to function properly, line 11 should have been hit instead.
When the break statement is hit instead of the incoming message being processed and pointers being set up to optional parameters, then data (the pointers that shouldve been held) is overwritten
The error correction software identified the data overwrite and initiated a shutdown of the switch for a reset. This issue was compounded because this flawed software was present in all switches across the network, leading to a chain reaction of resets that ultimately crippled the entire network system.

Despite having a network designed for resilience, one line of code was able to bring down half the countrys main line of communication.

The Fix 🔨

It took engineers 9 hours to get AT&Ts system fully back online. They did so mostly by rolling back the switches to a previous, working version of code.

It actually took software engineers two weeks of rigorous code reading, testing, and replication to actually understand where the bug was.

Conclusion 💭

For AT&T, unfortunately, this wasnt even their biggest system crash of the 90s. They encountered many more issues later in the decade.

In reality, it wasnt one line of code that brought down a system. It was a failure in processes.

Todays companies have even better processes in place, and even then, bugs slip through. Google wrote a great retrospective on 20 years of Site Reliability Engineering, where they reflect on YouTubes first global outage in 2016.

The scale of an outage for companies is huge and there are lessons to be learned from each outage. For most, however, outages come down to human error and gaps in processes.

Connect with Me on social media 📲

🐦 Follow me on Twitter: devangtomar7

🔗 Connect with me on LinkedIn: devangtomar

📷 Check out my Instagram: be_ayushmann

Checkout my blogs on Medium: Devang Tomar

# Checkout my blogs on Hashnode: devangtomar

🧑💻 Checkout my blogs on Dev.to: devangtomar

How Facebook Keeps Millions of Servers Synced 🕰️⏰

Devang Tomar — Fri, 26 Jan 2024 05:31:44 +0000

If youre running a distributed system, its incredibly important to keep the system clocks of the machines synchronized. If the machines are off by a few seconds, this will cause a huge variety of different issues.

You can probably imagine why unsynchronized clocks would be a big issue, but just to beat a dead horse

Today, lets dive into the intricate world of time synchronization at Meta. Buckle up, its not just about ticking clocks; its about the heartbeat of millions of servers! 💻🌐

Why Sync Matters

Running a distributed system? Syncing system clocks is crucial! 🔄 Unsynchronized clocks? Brace yourself for data inconsistency, log chaos, security issues, and more! Facebook knows this too well.

🌐 Meet NTP and PTP

NTP: Old but gold. Syncs computers within milliseconds. How? Clients talk to NTP servers, adjusting internal time based on roundtrip delays.

PTP: The shiny new kid. Precision to nanoseconds or even picoseconds! It tackles network delays with hardware timestamping. But, watch out for the load it places on network hardware! 💽

🌟 Facebooks Sync Symphony

NTP Days: Facebook danced with Ntpd and Chrony. Chrony brought nanoseconds to the party, but the story doesnt end there.

PTP Era: In 2022, Facebook waved goodbye to NTP, embracing Precision Time Protocol for superior precision and scalability. Say hello to nanosecond accuracy! 🚀

Absolutely, lets break down the details of Metas pursuit of nanosecond accuracy using Precision Time Protocol (PTP) and the key components involved:

🏹 Aim: Nanoseconds! 🎯

Metas shift to PTP comes with the ambitious goal of achieving nanosecond-level accuracy in time synchronization. This precision is crucial in the fast-paced world of distributed systems where every second matters.

🌐 Components Leading the Charge

PTP Rack

The PTP Rack is the nerve center, housing the hardware and software responsible for serving time to clients. Heres what makes it tick:

GNSS Antenna : This critical component communicates with the Global Navigation Satellite System (GNSS). It ensures that the PTP system is in sync with the global positioning signals, enhancing accuracy.
Time Appliance: A dedicated piece of hardware residing in the PTP Rack. It combines a GNSS receiver and a miniaturized atomic clock. This combination ensures that even in scenarios where GNSS connectivity is lost, the Time Appliance can maintain accurate timekeeping independently.

The PTP Rack, with its GNSS synchronization and atomic clock precision, sets the stage for achieving the nanosecond goal.

The Network

The network plays a pivotal role in transmitting PTP messages from the PTP Rack to clients. Meta employs unicast transmission, a communication method where information flows from one sender (PTP Rack) to a single recipient (PTP Client). This choice simplifies network design and enhances scalability.

Unicast transmission ensures that each client receives the necessary time synchronization information directly from the PTP Rack, reducing the complexity that could arise in a multicast setup.

PTP Client

Running on individual machines, the PTP Client is the endpoint that actively communicates with the PTP network. Meta uses an open-source PTP client called ptp4l for this purpose. However, the implementation wasnt without its challenges, especially when dealing with edge cases.

Open Source Client: Ptp4l is an open-source implementation, reflecting Metas commitment to transparency and community collaboration. Its a tool that facilitates communication between the PTP Rack and individual servers, allowing them to synchronize their clocks with nanosecond precision.
Challenges with Edge Cases: While ptp4l is a robust tool, Meta acknowledges challenges faced in specific scenarios or with certain types of network cards. These edge cases required additional attention to ensure the seamless functioning of the PTP system.

🌟 Benefits of the PTP System

Higher Precision and Accuracy: The PTP system allows Meta to achieve precision within nanoseconds, a significant leap from the millisecond-level synchronization provided by traditional methods like NTP.
Better Scalability: Unicast transmission reduces the frequency of check-ins required for synchronization, enabling smoother network operation as the system scales. A single source of truth for timing enhances overall scalability.
Mitigation of Network Delays and Errors: PTPs focus on hardware timestamping and transparent clocks helps reduce the impact of network delays and errors, contributing to a more robust and reliable synchronization process.

In essence, the PTP trioPTP Rack, The Network, and PTP Clientembodies Metas commitment to precision, scalability, and overcoming challenges in the pursuit of nanosecond-level accuracy in time synchronization.

🌐 Network Time Strata Explained:

NTP organizes computers into hierarchical layers called strata based on their proximity to highly accurate time sources, typically atomic clocks or GPS receivers. Each stratum represents a level in the hierarchy, and the lower the stratum number, the closer a device is to the primary time source.

1. Stratum 0: Atomic Clock or GPS Receiver:

At the top of the hierarchy are devices with direct access to incredibly precise timekeeping mechanisms, such as atomic clocks or GPS receivers.
Stratum 0 devices serve as the primary time source for the entire synchronization network.

2. Stratum 1: Directly Synced with Stratum 0:

Stratum 1 devices are directly synchronized with Stratum 0 devices. These could be servers or systems that have a direct connection to the primary time source.
Stratum 1 devices act as secondary time sources for the next level of devices in the hierarchy.

3. Stratum 2: Syncs with Stratum 1:

Stratum 2 devices synchronize their clocks with Stratum 1 devices. These devices are one step further away from the primary time source.
Stratum 2 devices act as time sources for devices in the subsequent stratum.

4. and so on, until Stratum 15: Indicating Unsynced Devices:

The strata continue in a cascading manner, with each stratum representing a level of hierarchy further away from the primary time source.
As the stratum number increases, the accuracy of time synchronization decreases.

5. Stratum 16: Unsynced Devices:

Stratum 16 is a special designation used to indicate devices that are not synchronized with any source. It represents the highest stratum number and signifies unsynchronization.

🔄 How Synchronization Works

Computers in lower strata synchronize their clocks with devices in higher strata. For example, Stratum 2 devices synchronize with Stratum 1 devices, and so on.
Multiple devices in the same stratum can be synchronized with different devices in a higher stratum, introducing redundancy and fault tolerance.

🔍 Why the Hierarchy Matters

The hierarchical structure ensures that not every device needs to directly synchronize with the most accurate time source. This arrangement prevents overloading a single time server with numerous synchronization requests.
The hierarchy allows for redundancy and fault tolerance. If a device in a lower stratum loses synchronization, it can quickly switch to another source in the same stratum or a higher one.

🌟 Benefits

Efficient Synchronization: Devices in lower strata benefit from the accuracy of those in higher strata, optimizing the synchronization process.
Scalability: The hierarchical structure scales well, allowing for the expansion of the synchronization network without overwhelming primary time sources.

Understanding Network Time Strata provides insights into how NTP organizes and maintains time synchronization across a distributed system, ensuring accuracy and efficiency in timekeeping.

🚀 Conclusion

Syncing clocks isnt just about ticking seconds; its the heartbeat of a well-functioning system. Facebooks journey from NTP to PTP showcases the relentless pursuit of precision and scalability. Time, after all, waits for no server! 💡

What are your thoughts on Metas clockwork precision? Share your views! 👇

Happy Syncing! 🌐🚀

Connect with Me on social media 📲

How Cloudflare Achieved 55 Million Requests per Second with Just 15 PostgreSQL Clusters! 💻

Devang Tomar — Fri, 19 Jan 2024 05:32:15 +0000

In the vast landscape of the internet, Cloudflare emerged in July 2009, founded by a group of visionaries with the goal of making the internet faster and more reliable. The challenges they faced were immense, but their growth was nothing short of spectacular. Fast forward to today, and Cloudflare serves a whopping 20% of the internets traffic, handling a staggering 55 million HTTP requests per second. The most incredible part? They achieved this feat with only 15 PostgreSQL clusters. Lets dive into the magic behind this impressive system design!

PostgreSQL Scalability: The Core 🚀

Resource Usage Optimization with PgBouncer 🔄

Handling Postgres connections efficiently is crucial, and Cloudflare uses PgBouncer as a TCP proxy to manage a pool of connections to Postgres.

This not only prevents connection starvation but also tackles the challenge of diverse workloads from different tenants within a cluster.

Thundering Herd Problem Solved! 🐘

The infamous Thundering Herd Problem, where many clients query a server concurrently, was addressed by Cloudflare using PgBouncer. It smartly throttles the number of Postgres connections created by a specific tenant, preventing degradation of database performance during high traffic.

Performance Boost with Bare Metal Servers and HAProxy

Cloudflare opts for bare metal servers without virtualization, ensuring high performance. They leverage HAProxy as an L4 load balancer, distributing traffic across primary and secondary database read replicas, providing a robust solution for performance enhancement.

Congestion Avoidance Algorithm for Concurrency 🚧

To manage concurrent queries and avoid performance degradation, Cloudflare employs the TCP Vegas congestion avoidance algorithm.

This algorithm samples each tenants transaction round-trip time to Postgres, dynamically adjusting the connection pool size to throttle traffic before resource starvation occurs.

Ordering Queries Strategically with Priority Queues 📊

Cloudflare tackles query latency by ranking queries at the PgBouncer layer using queues based on historical resource consumption.

Enabling priority queuing only during peak traffic ensures that queries needing more resources are handled efficiently without causing resource starvation.

High Availability with Stolon Cluster Manager 🌐

Ensuring high availability is a top priority for Cloudflare. They employ the Stolon cluster manager, replicating data across Postgres instances, and performing failovers seamlessly in peak traffic. With data replication across regions and proactive network testing, Cloudflare ensures a robust and resilient system.

Conclusion 🌈

Cloudflares journey to handling 55 million requests per second with just 15 PostgreSQL clusters is a testament to their ingenious system design. From smart connection pooling to tackling concurrency and ensuring high availability, theyve navigated the complexities of scaling with finesse. Subscribe to our newsletter for more simplified case studies and unravel the secrets behind the tech giants success! 🚀🔍