In the world of digital platforms, fraud is not just a possibility — it’s a certainty. Whether you’re running an e-commerce platform, a digital wallet, or a food delivery app, fraudsters are constantly seeking ways to extract benefits at your expense. And as your platform scales, the cost of inaction becomes more expensive than ever.

Let’s break down what fraud is, why chargebacks sting, and why you can’t eliminate fraud — but you can outpace it with the right systems in place.

What Is Fraud?

Fraud can take many forms, but at its core, it’s an intentional deception to secure unfair or unlawful gain. On platforms, this typically includes:

• Refund fraud: A customer falsely claims an item never arrived or was defective to get their money back.
• Promo abuse: Creating multiple accounts to exploit first-time user discounts.
• Card fraud: Using stolen credit card information for purchases.
• Chargeback fraud: A customer initiates a chargeback (a reversal of a credit card payment) despite having received the product or service.

Fraudsters aren’t always sophisticated. Sometimes they’re regular users who spot a loophole and exploit it. And that makes prevention even trickier.

What Is a Chargeback — and Why It Hurts

A chargeback is when a customer disputes a transaction and the issuing bank forcibly reverses the charge. It was designed as a consumer protection tool — but for businesses, it’s a nightmare.

Why? Because:

• You lose the product or service and the money.
• You often pay additional fees.
• Too many chargebacks raise your dispute rate, risking higher transaction fees or even getting banned by payment processors.

Worse still, you rarely get to explain your side of the story. The decision is often automated, and the default stance is: The customer is right.

You Can’t Eliminate Fraud — You Can Only Get Better at Fighting It

Here’s the hard truth: fraud is a moving target.

Every time you build a defense system — captcha, OTP verification, velocity limits, KYC — fraudsters evolve. You solve one puzzle, you land on another.

So instead of chasing a perfect solution, aim to:

• Minimize impact: Reduce the financial and operational damage.
• Increase friction for bad actors, but not for your good users.
• Build faster feedback loops so you can react to new fraud patterns quickly.

Why You Need Guardrails in Your System

Guardrails are the protective mechanisms baked into your platform — the silent defenders that flag, block, or limit risky behaviors.

What do guardrails look like?

• Refund limits: One refund per user per month.
• Velocity checks: Limit the number of orders, logins, or cards per device.
• Behavioral signals: Flag accounts that show suspicious patterns — too many password resets, multiple failed payments, etc.
• Device fingerprinting: Detect if the same device is being used to create multiple accounts.

These don’t just prevent fraud — they deter it. If a fraudster hits a wall early, they’re less likely to keep probing your system.

Fraud Is a Product Problem — Treat It Like One

Fraud prevention is not just a security concern or a customer support task. It’s a product and engineering challenge. Treat it like any other product domain:

• Set metrics: % chargeback rate, fraud losses per order, false positive rate.
• Run experiments: What happens if you change your refund window? Your KYC rules?
• Talk to real users — and your fraud team. Often, your best insights come from people on the ground.

Don’t Wait for a Blow-Up

Too often, companies ignore fraud until they hit a PR disaster or payment processor threat. But the damage by then is already done — in dollars and trust.

Build guardrails. Monitor abuse. Revisit thresholds. Iterate.

Because fraud doesn’t rest — and neither should your systems.

🔚 Final Thought

Fighting fraud is not about reaching 0%. That’s a myth. It’s about staying a step ahead and making it painful enough for fraudsters to go elsewhere. Every puzzle you solve helps your platform mature — and every guardrail you build protects your real users better.

Stay sharp. Keep shipping. And always expect the next move.

As 2024 comes to a close, it’s hard to believe how much has happened in just one year. For me, this year has been filled with challenges, growth, and learning — both professionally and personally. From diving deep into the startup ecosystem to launching events that brought people together through creativity, it has been a year of experimentation, hard work, and collaboration.

Here’s a look back at my 2024 journey, from building on Exp.club with other cofounders to starting my own business, Eksau.in, and all the experiences that shaped my year.

Starting the Year with Exp.club

exp.club | learn by building a real product with a real team

At the start of 2024, I was deeply involved in a project that I believed had the potential to make a significant impact — Exp.club. The concept was simple yet ambitious: we wanted to help students and professionals learn how to build their own products. The idea was to create a community where developers, designers, and product managers could collaborate, learn, and execute together.

Within a month, we launched three cohorts — each one made up of a diverse group of people with a shared goal: to build a product from scratch. Our mission was to guide these aspiring creators on every step of their journey, from ideation to launch. It was an incredibly fulfilling experience to watch these teams come together, collaborate, and bring their ideas to life.

However, despite the positive impact and potential I saw, I made the difficult decision to step away from Exp.club. As much as I loved the project, I realized that the startup required my full attention and bandwidth — something I wasn’t able to give due to my regular job. I truly believe that with the right focus, Exp.club has the potential to grow exponentially, but it needed more than I could offer at that time.

Looking back, though, I’m incredibly grateful for the relationships I built and the lessons I learned. I had the pleasure of working with my co-founders, Ankur Goyal and Dipti Mundra, who I met through Ycombinator. Getting to know them was an absolute joy, and I learned a tremendous amount from their perspectives, wisdom, and work ethic. If you’d like to explore more about Exp.club, check out Exp.club.

The Birth of Eksau.in

After stepping away from Exp.club, I took some time to reflect on my next steps. It wasn’t long before I found my next adventure — and this time, I was venturing into a completely different space. Enter Eksau.in, my very own e-commerce venture.

Eksau is a curated collection of 100 different kinds of products — from home décor to a variety of lifestyle items, with a vision to create a space where quality and creativity meet.

I started this business alongside my good friend Saumya Sisodia, who has been an invaluable partner in this journey. Saumya brings immense expertise to the table, especially in areas like creativity, marketing, sales, and relationship management. We’ve worked together to build a brand that resonates with our customers and offers a truly curated experience.

In the early days, we focused on home décor, launching a range of beautifully designed products we felt were missing in the market. It was a small but exciting step, and we were both thrilled to see customers respond positively.

But what truly made this year stand out were the events we hosted. Two events, in particular, were close to my heart and filled me with a sense of purpose.

Event 1: A Creative Ceramics Session

The first event we hosted was a small, intimate gathering, held in a closed group setting. We invited people to come and paint ceramics, giving them the chance to express themselves creatively. It was such a fulfilling experience to see people of all skill levels paint their hearts out on these ceramics — some made beautiful bowls, others painted mugs or plates. There was food, laughter, and a sense of community in the air.

This event wasn’t just about selling products; it was about bringing people together, fostering creativity, and creating memories. The feedback from the participants was overwhelmingly positive, and we were excited to host more such events in the future.

Event 2: Art for a Cause — NGO Event

The second event was incredibly special to me. It took place on 31st October, and we partnered with an NGO to bring together a group of individuals who had the chance to express their creativity through art. We provided them with canvases, paints, and a safe space to create. What made this event even more powerful was that these pieces of art were not just for personal enjoyment but were gifted to government officials as a gesture of appreciation.

Seeing these individuals — many of whom had never painted before — pour their hearts into their artwork and then proudly gift it was incredibly moving. It reminded me that creativity has the power to bring people together and make an impact in ways that go beyond just products.

This event is something I will always hold dear to my heart, as it reminded me that business can be about more than just making a profit — it can be about purpose, community, and giving back.

Challenges: The Packaging Dilemma

As with any new venture, there were challenges along the way. One of the biggest hurdles we faced at Eksau was packaging. Selling products online comes with its own set of logistics, and we quickly learned how complex and time-consuming the packaging process could be. We wanted to ensure that every product reached our customers in perfect condition, but as our orders increased, so did the packing challenges.

While this slowed our momentum a bit, it also gave us the opportunity to rethink and streamline our processes. We’re continuously working on finding solutions that will help us scale efficiently while maintaining the quality and service that our customers expect.

Reflections and Looking Ahead

2024 has been a year of transformation — one filled with new projects, unexpected turns, and invaluable lessons. From the excitement of building Exp.club and learning about product creation, to the joy of starting Eksau.in with Saumya and hosting events that brought people together, it’s been a year of growth in every sense.

Looking ahead, I am filled with a sense of gratitude and optimism for what the future holds. There is still so much to learn, so much to build, and so many more people to meet. As I continue to explore new ventures and creative projects, I’m reminded of how much we can accomplish when we pursue things with passion, collaboration, and an open heart.

Thank you to everyone who has been part of this journey — to my teammates, friends, mentors, and everyone who supported me along the way. I’m excited for what 2025 has in store and can’t wait to see what we can build together next.

Here’s to the next chapter!

What was your 2024 like? If you’ve been through any exciting projects, challenges, or experiences this year, feel free to share in the comments. Let’s keep the conversation going! 🌟

Introduction

Python, a language known for its simplicity and versatility, relies heavily on dictionaries, also known as maps. These dictionaries play a crucial role in various operations, offering swift data access. But have you ever wondered how they manage to be so fast and efficient? The secret lies in hashing, a fundamental concept we’ll explore in this blog, along with how dictionaries are structured internally.

Hashing: The Magic Behind Dictionaries

Imagine you have a bunch of keys (inputs) that you want to keep organized. Instead of arranging them linearly, a hash function is used. This function takes each key, processes it, and produces a compact code, or hash. This hash is like a cheat sheet, telling us where the actual data (values) is stored. This makes finding values incredibly quick, especially with large datasets.

Storing Data: The Hash Table

Think of a hash table as a huge, organized collection of buckets, each labeled with a unique number. These buckets are where our data resides. When we want to store or retrieve something, we consult the hash, which tells us which bucket to look in.

Tackling Hash Collisions

Hashing sounds perfect, right? Well, not always. There’s a tiny hiccup: what if two different keys produce the same hash? This is a hash collision, and it’s like two people ending up with the same locker number. Python deals with this using two main methods:

1. Chaining: Imagine each bucket having its own mini-list inside it. When two keys collide, they are placed in the same mini-list, sharing the bucket. It’s like having a shared locker for two friends.

2. Open Addressing: In this approach, if a bucket is already taken, Python looks at the next available bucket until it finds an empty one. It’s like finding an empty locker by moving to the nearest available one.

Python’s Dictionary Magic

Python’s dictionaries have a lot going on behind the scenes to make them efficient:

1. Flexible Hashing: Python uses a hash function that can process various types of data, making it possible to use diverse keys.

2. Changing Sizes: Dictionaries can grow or shrink as needed, ensuring they’re always optimized for your data.

3. Preserving Order: Since Python 3.7, dictionaries also remember the order in which keys were added, which is great for tasks that require maintaining input order.

Performance: A Peek into Time Complexity

In simple words, Python dictionaries are super-fast. On average, tasks like adding, removing, or fetching data have a consistent speed, regardless of the dictionary’s size. However, in rare cases where many hash collisions occur, the speed can decrease, but Python’s clever design minimizes this issue.

Conclusion

Python’s dictionaries are a behind-the-scenes hero, ensuring our code runs efficiently. By understanding hashing and the way dictionaries manage data internally, we gain insights into why Python is so good at what it does. Whether you’re a newbie or a seasoned coder, the inner workings of dictionaries shed light on the core of Python’s power, making your coding journey even more fascinating.

Introduction

In the realm of artificial intelligence and machine learning, there’s a fascinating concept called “supervised learning” that has the power to transform our lives in countless ways. At first glance, it might sound complex, but fear not! In this beginner-friendly guide, we’ll take a journey into the world of supervised learning, demystify its secrets, and discover the wonders it can bring to our daily lives.

Understanding Supervised Learning

So, what exactly is supervised learning? Think of it as a way to teach machines to learn from examples. Imagine you’re teaching a kid how to identify different animals. You show them pictures of cats, dogs, and elephants, and you tell them what each animal is. Gradually, the kid starts recognizing the unique features of each animal and can tell you what they are just by looking at new pictures. That’s what supervised learning is all about!

In this process, we use a labeled dataset, which means we have lots of examples with their correct answers. The dataset contains features (like the different attributes of an animal) and the corresponding labels (what type of animal it is). The goal is to build a “smart” model that can learn from these examples and make accurate predictions when faced with new, unseen data.

Getting to Know the Parts

Let’s break down the key components of supervised learning in simple terms:

1. Input Data: This is the information that goes into the model for learning. Just like the pictures of animals, we showed the kid, it can be anything, like numbers, text, pictures, or even sounds.
2. Target Labels: These are the correct answers we want the model to learn. Going back to our example, the labels were “cat,” “dog,” and “elephant.” The model’s job is to figure out the relationship between the input data and the correct labels.
3. Model Architecture: This is like the brain of the model. It’s a fancy mathematical structure that learns patterns and relationships from the examples we give it.
4. Loss Function: Think of this as a way to measure how well the model is doing. It tells the model how far off its predictions are from the correct answers.
5. Optimization Algorithm: This is like the model’s teacher. It helps the model adjust its “thinking” process to get better at making predictions.

Different Types of Supervised Learning

Supervised learning comes in two main flavors:

1. Classification: It’s like sorting things into categories. For example, it can help us classify emails as “spam” or “not spam” or recognize whether a picture contains a cat or a dog.
2. Regression: This one deals with predicting numbers. For instance, it could help us predict house prices based on factors like the number of rooms, location, and size.

The Challenges and Solutions

No learning journey is without challenges! Two common issues are “overfitting,” where the model becomes too focused on the training examples and fails to generalize to new data, and “biased datasets,” which lead to biased predictions. To overcome these obstacles, we use techniques like cross-validation to test the model’s performance and regularization to prevent overfitting.

Exciting Applications of Supervised Learning

Now comes the fun part — seeing supervised learning in action in our lives! It’s everywhere:

1. Healthcare: Doctors use it to predict patient outcomes and suggest personalized treatments.
2. Finance: Banks employ it to detect fraud and make credit risk assessments.
3. Language and Speech: Virtual assistants like Siri or Alexa understand our commands thanks to supervised learning.
4. Image Recognition: It helps us find objects in pictures and enables facial recognition.

Conclusion

Supervised learning might sound like magic, but it’s a magical innovation that drives the world of AI and machine learning. By teaching machines to learn from examples, we can achieve incredible feats and solve complex problems. As we continue to explore this amazing field, supervised learning will undoubtedly lead us into a future where machines can assist and augment our capabilities, making our lives better in ways we couldn’t have imagined before. So, embrace the magic of supervised learning, and let’s embark on an exciting journey into the world of AI!

Hey there! Have you ever wondered how some apps and systems seem to know exactly what you need or like? Well, it’s not magic; it’s machine learning! This fascinating technology is all about teaching computers to learn from data and make smart decisions without being explicitly told what to do. So, let’s dive into the world of machine learning together and discover the key concepts that make it tick! Also, I will be writing entire series on machine learning, so do follow the blogs which I am writing if you want to deep dive into it.

What’s the Big Deal with Machine Learning?

Okay, picture this: instead of following fixed rules, machine learning lets computers learn from examples and experiences, just like we do. Imagine showing a computer countless cat pictures and telling it, “Hey, these are cats!” Then, it looks at new pictures and starts recognizing cats on its own. It’s like teaching a super-smart pet that never forgets!

The Three Types of Machine Learning:

Now, let’s break down the types of machine learning, which are like different learning styles for our computer buddy:

a. Supervised Learning: Here, we give computer-labeled examples to learn from. For instance, we’ll show it pictures of cats labeled “cat” and pictures of dogs labeled “dog.” The computer figures out the patterns and can identify cats and dogs in new pictures.

b. Unsupervised Learning: In this style, we don’t label the examples. Instead, we ask the computer to look for hidden patterns by itself. For example, if we show it pictures of various animals without labels, it may group similar animals based on their features.

c. Reinforcement Learning: This one’s like training a puppy to perform tricks. The computer, or agent, interacts with an environment and gets rewards when it does something right. Over time, it learns to take actions that bring the most rewards. It’s like learning through trial and error.

What’s the procedure to make machines learn?

Preparing the Data:

Before the computer starts learning, we need to prepare the data, like tidying up before a big event. Data might be messy with missing information or irrelevant stuff. So, we clean it up, organize it, and make sure it’s ready for the learning process.

Picking the Right Model:

Choosing the right machine learning model is like picking the perfect tool for the job. Different models have different strengths, and we want the one that suits our task best. It’s like using a wrench for bolts and a screwdriver for screws.

Training and Testing:

Alright, let’s start teaching the computer! We train it using the labeled examples, and it learns to make predictions. But we can’t just trust it blindly. We need to test its skills on new, unseen examples to see if it’s really learning or just pretending.

Avoiding Traps: Overfitting and Underfitting

Okay, there are a couple of traps our computer learners might fall into. Overfitting is when it memorizes the examples so well that it can’t handle new ones. It’s like memorizing answers without understanding the concepts. On the other hand, underfitting is when it doesn’t learn enough and performs poorly even in the training examples. We want our computer buddy to find the right balance, just like we do in our studies.

Where Machine Learning Works Its Magic:

Machine learning has superpowers that make our lives better in many ways:

• It’s behind those chatbots that seem almost human-like.
• It’s what makes your favorite app recommend the perfect song or movie for you.
• It helps doctors diagnose diseases more accurately and quickly.
• It keeps our online transactions secure by detecting fraudulent activities.

Conclusion:

So, there you have it! Machine learning is like having a smart, learning friend in the digital world. It’s all about using data to teach computers to make decisions and spot patterns on their own. Whether it’s recognizing cats, organizing animals, or helping doctors save lives, machine learning has transformed our lives in countless amazing ways. As technology keeps advancing, this friendly magic will keep surprising us with even more wonders!

Edit distance, also known as Levenshtein distance, is a metric used to quantify the similarity between two strings. It measures the minimum number of single-character edits (insertions, deletions, or substitutions) required to transform one string into the other. The name “Levenshtein distance” comes from the Russian mathematician Vladimir Levenshtein, who first introduced the concept in 1965.

The three basic types of single-character edits are:

1. Insertion: Adding a single character to one of the strings.
2. Deletion: Removing a single character from one of the strings.
3. Substitution: Replacing a character in one of the strings with another character.

“In Levenshtein’s domain, edit’s the game 🎮,

Change, add, or delete 📛, each move has its name .

Distance📍 we find, the characters’ plight ,

By counting ⏲️ the edits, to make them unite.

Levenshtein distance, it measures the space 🛰️,

Transforming the strings, at a steady pace🚶.

The smallest of changes, we aim 🎯 to pursue ,

In words and in code, it’s a tool that’s true.” 👯

Let’s understand it with an example

Consider the following two strings:

String 1: “Saturday”

String 2: “Sunday”

To find the edit distance between these two strings, we need to determine the minimum number of single-character edits (insertions, deletions, or substitutions) required to transform “Saturday” into “Sunday.”

Here’s how we can do it step by step:

Step 1: Compare the first characters of both strings:

• The first character of String 1 is “S.”
• The first character of String 2 is “S.”

The characters are the same, so no edit is needed. Our strings remain the same:

Saturday → Sunday

Step 2: Compare the second characters of both strings:

• The second character of String 1 is “a.”
• The second character of String 2 is “u.”

Since the characters are different, we need to perform a substitution operation to change “a” to “u.” Our strings now look like this:

Suturday → Sunday

Step 3: Compare the third characters of both strings:

• The third character of String 1 is “t.”
• The third character of String 2 is “n.”

Again, the characters are different, so we need to perform a substitution operation to change “t” to “n.” Our strings become:

Sunurday → Sunday

Step 4: Compare the fourth characters of both strings:

• The fourth character of String 1 is “u.”
• The fourth character of String 2 is “d.”

Once more, the characters are different, so we need to perform a substitution operation to change “u” to “d.” Our strings now look like this:

Sundrday → Sunday

Step 5: Compare the fifth characters of both strings:

• The fifth character of String 1 is “r.”
• The fifth character of String 2 is “a.”

Yet again, the characters are different, so we need to perform a substitution operation to change “r” to “a.” Our strings become:

Sundaday → Sunday

Step 6: Compare the sixth characters of both strings:

• The sixth character of String 1 is “d.”
• The sixth character of String 2 is missing.

Since String 2 is shorter than String 1, we need to perform a deletion operation to remove the “d” from String 1. Our strings now look like this:

Sunday → Sunday

Now, we have successfully transformed “Saturday” into “Sunday” using four operations: four substitutions and one deletion. Therefore, the edit distance between “Saturday” and “Sunday” is 5.

Where to apply edit distance?

• Edit distance has various applications in fields like computer science, natural language processing, bioinformatics, and more.
• It is widely used in spell-checking, DNA sequence comparison, plagiarism detection, and string similarity comparison in general. By calculating the edit distance between two strings, we can understand how similar or different they are based on the number of operations needed to transform one string into the other.

Go is a programming language that was created by Google in 2007. It is an open-source language becoming increasingly popular for its simplicity, speed, and ability to handle concurrency.

There are several reasons why you might choose to use Go for your programming projects. Here are some of the key benefits:

1. Concurrency: Go was designed from the ground up to be a concurrent language, which means it is well-suited for applications that need to handle multiple tasks simultaneously. Go includes built-in support for goroutines, which are lightweight threads that can be used to perform tasks concurrently, and channels, which allow for safe communication between goroutines. This makes it easy to write code that can take advantage of multiple CPU cores, resulting in faster and more efficient programs.
2. Speed: Go is a compiled language, which means that it is typically faster than interpreted languages like Python or Ruby. The Go compiler produces machine code that can be executed directly by the computer’s processor, resulting in faster execution times.
3. Simplicity: Go was designed to be easy to learn and use. The syntax is straightforward and easy to read, and the language includes a minimal set of features. This makes it a good choice for beginners, as well as experienced programmers who want to quickly develop efficient and effective code.
4. Safety: Go includes several features that make it easier to write safe and secure code. For example, it includes strong typing, which can help prevent type-related errors, and a garbage collector, which helps prevent memory leaks. Additionally, Go’s emphasis on concurrency means that it includes built-in support for synchronization and mutual exclusion, making it easier to write code that is free from race conditions and other concurrency-related bugs.
5. Large standard library: Go includes a large standard library that provides support for a wide range of tasks, from handling HTTP requests to working with databases. This means that you can often accomplish complex tasks without needing to use third-party libraries or frameworks.
6. Cross-platform compatibility: Go is designed to be cross-platform compatible, which means that code written on one platform can be easily ported to other platforms without modification. This makes it easier to write code that works on multiple operating systems and devices.

Overall, Go is a powerful and versatile programming language well-suited for a wide range of applications. Its emphasis on concurrency, speed, simplicity, safety, and a large standard library makes it a good choice for everything from web development to system programming.

Primary Key:

In a DynamoDB table, we will always have a primary key. The primary can consist of just a partition key (Simple Primary Key) or the combination of a partition key and a sort key (Composite Primary Key).

Partition and Partition key:

Partition is simply a logical separation or group of machines that are hosting your data for instance if you have hundreds of GB of data in your table, DynamoDB may create multiple partitions based on a key to separate out the data across these partitions.

When a query comes in for a particular key, dynamo uses a particular key’s value which is called the partition key as the input to a hashing function and spits out the location of the record. Using this technique, dynamo can quickly go to the location and fetch the records with very very high performance.

This diagram shows the organization of cart records placed by a user in a Cart table. Each order is uniquely identified by a combination of userID and cartID.

Why choosing the right partition key is important?

Limit your access pattern: If you’re designing a table for the long term, it is essential to be aware of the implications of picking a certain type of key or key combination because it can actually limit the type of queries you can perform on your table.

Throttling: It can occur when you have a bad table design that’s conducive to hot partitions or, in simple terms, When the amount of resources you’re trying to use exceeds the amount that you’ve provisioned on the table.

Things to keep in mind, when choosing a partition key in DynamoDB:

1. Even distribution: Select a partition key that ensures that the data is evenly distributed across its partitions. This can help avoid hot partitions, leading to throttling of requests and poor performance.
2. Data access patterns: Choose a partition key that aligns with your data access patterns. This can help improve query performance and minimize the amount of data scanned.
3. Uniqueness: The partition key should be unique across all items in the table. This is because all items with the same partition key are stored on the same partition.
4. Avoid frequent updates: Choose a partition key that is not frequently updated. Frequent updates to the same partition key can lead to hot partitions and poor performance.
5. Large cardinality: Choose a partition key with a large number of distinct values relative to the number of items in the table. This can help ensure the even distribution of data across partitions.

By keeping these considerations in mind, you can select an appropriate partition key for your DynamoDB table that ensures good performance and scalability.

Splitwise is a financial management app that helps people easily split expenses with friends and family. With Splitwise, users can create expenses for things like rent, groceries, or a night out, and then specify which friends or family members are involved in the expense. The app then calculates how much each person owes and keeps track of who has paid their share.

Splitwise also has features for settling debts between users, generating reports, and integrating with payment systems such as PayPal or Venmo. This makes it easier for people to track shared expenses and ensure that everyone is paid back fairly.

To create a Splitwise app in Go (also known as Golang), you’ll need to have a basic understanding of the Go programming language, Here’s a high-level overview of the steps you might take:

1. Design your app’s architecture. This will involve deciding how to structure your code, what packages and dependencies you’ll need, and how you’ll handle things like data storage and user authentication.
2. Implement the app’s core functionality. This will include writing code to handle things like creating and managing expenses, splitting costs between users, and generating reports.
3. Create a user interface for your app. This will involve writing HTML, CSS, and JavaScript code to create a web-based interface that users can interact with.
4. Test your app thoroughly. This will involve writing unit tests and integration tests to ensure that your app is reliable and performs as expected.

Keep in mind that this is just a high-level overview, and there will be many details and challenges to address as you work on your Splitwise app. It’s a good idea to start small and gradually add features as you become more comfortable with Go and web development.

Backend of splitwise app :

The back-end of a Splitwise app is responsible for handling the business logic and data storage for the app. This might include handling user authentication, creating and managing expenses, calculating splits, and generating reports. We are going to write basic code for splitting the money but in actual implementation, you’ll have to use a database to store data such as user accounts, expenses, and payment information.

package main

import "fmt"

// User represents a user in the app.
type User struct {
 ID int
 Name string
}

// Expense represents an expense in the app.
type Expense struct {
 ID int
 Description string
 Amount float64
 Payers []User
 Split float64
}

func splitMoney(expense Expense) []float64 {
 splitAmounts := make([]float64, len(expense.Payers))
 for i, payer := range expense.Payers {
  splitAmounts[i] = expense.Amount / float64(len(expense.Payers))
 }
 return splitAmounts
}

func main() {
 // Create some users.
 alice := User{ID: 1, Name: "Alice"}
 bob := User{ID: 2, Name: "Bob"}
 charlie := User{ID: 3, Name: "Charlie"}

 // Create an expense and split it evenly between the users.
 expense := Expense{
  ID: 1,
  Description: "Dinner at restaurant",
  Amount: 100,
  Payers: []User{alice, bob, charlie},
 }

 splitAmounts := splitMoney(expense)
 for i, payer := range expense.Payers {
  fmt.Printf("%s owes $%.2f\n", payer.Name, splitAmounts[i])
 }
}

This is just a high-level overview of the main components and technologies that might be involved in building a Splitwise app. There are many other details and considerations that would need to be addressed as part of the app’s architecture, such as security, scalability, and performance.

If you’re working with message queue systems, you’ve likely come across Amazon Simple Queue Service (SQS) and Apache Kafka. Both of these tools are designed to enable the asynchronous exchange of data between systems, but they have some key differences that you should be aware of.

The main difference between SQS and Kafka is the type of message delivery they offer.

SQS is a fully managed message queue service that offers two types of message delivery: standard and FIFO (first-in, first-out). Standard delivery allows for messages to be delivered more than once, while FIFO delivery ensures that messages are delivered in the order they were sent and without duplication.

At a high level, SQS stores and transports messages using a distributed system of servers. When a message is sent to an SQS queue, it is stored on one of these servers until it is retrieved by a consumer. This allows for the decoupling of producers and consumers, as the producer does not need to wait for the consumer to be available in order to send the message.

Kafka, on the other hand, is a distributed streaming platform that allows for the real-time processing of streaming data. It offers a publish-subscribe model for message delivery, which means that messages are sent to a topic and consumed by subscribers. Kafka also offers the ability to store messages for a configurable amount of time, which can be useful for handling late-arriving data or re-processing data.

At a high level, Kafka consists of a set of brokers that are responsible for storing and distributing messages. When a producer sends a message to a Kafka topic, the broker stores the message and makes it available to consumers. Consumers can then retrieve the message and process it as needed.

Another major difference between SQS and Kafka is the level of control they offer.

SQS is a fully managed service, which means that Amazon takes care of the underlying infrastructure and scaling. This can be convenient, but it also means that you have less control over the underlying architecture.

Kafka, on the other hand, is a self-managed platform, which gives you more control over the infrastructure and the ability to customize the setup to meet your specific needs.

Ultimately, the choice between SQS and Kafka will depend on your specific use case. If you need a fully managed message queue service with options for standard and FIFO delivery, SQS may be the right choice. On the other hand, if you need a distributed streaming platform with the ability to store and process real-time data, Kafka may be a better fit. It’s important to carefully evaluate your requirements and choose the tool that best meets your needs.