In this blog, I’ll walk you through how VideoAI works, from its processing flow to how it handles user queries. I’ll also highlight the exciting use cases that demonstrate the potential of this tool. Let’s dive in!

TL:DR

What is VideoAI?

VideoAI allows you to search video content as easily as you would query a database. It processes videos in the background, extracting and storing essential metadata so you can simply enter a query like “show me the crocodile” in a animal video and instantly find the corresponding moments in the video.

No more manual scrubbing through hours of footage—just ask, and VideoAI will deliver!

How VideoAI Works

This is the overall working of the app. It has 2 flows, viz., video processing flow and video querying flow.

Part 1: Uploading and Processing Your Video

The first step is uploading your video to VideoAI. Once uploaded, the platform begins to process it in the background. Here’s a step-by-step breakdown of how the magic happens:

1. Frame Extraction: VideoAI extracts frames from the video at regular intervals (e.g., every 1 second).

2. Captioning Each Frame: Using an image captioning model, VideoAI generates descriptive captions for each extracted frame. For example, if a frame contains a crocodile swimming in a lake, the model outputs something like, "a crocodile is swimming in the lake in the jungle."

3. Storing Captions in a Vector Database: These captions, along with their respective timestamps, are then stored in a vector database, making the video content searchable by time and description.

Step 2: Querying the Video

Once your video is processed, querying is as simple as typing or saying what you’re looking for. VideoAI takes your query—like "show me the monkey"—and performs the following:

1. Vectorizing Your Query: VideoAI converts your natural language query into a vector using the same embedding model that processed the video captions.

2. Searching the Vector Database: The system compares your query’s vector with the stored caption vectors in the database.

3. Returning the Relevant Timestamps: It then returns the exact timestamps of the frames that match your query, allowing you to jump straight to the moments you care about.

For instance, in a jungle-themed video containing animals like lions, monkeys, and crocodiles, you can search for "show me the crocodile," and VideoAI will return the precise timestamp where the crocodile appears.

Real-World Applications of VideoAI

VideoAI’s potential spans several industries and use cases. Here are a few exciting possibilities:

1. Surveillance Footage Analysis

Security operators can type in a natural language query like "person entering the building" or "car speeding" and VideoAI will return the exact moments in the surveillance footage where those events occurred. This feature could revolutionize how we handle and analyze security footage.

2. Rapid Media Curation for Broadcasters

Imagine a sports channel needing to curate the "best goals" or "top tackles" from a game. With VideoAI, they can pull these moments by simply querying those terms, saving countless hours of manual editing and review.

3. Video-Driven Search Engines

Picture a future where video search engines don’t rely solely on video titles, but on the actual content inside the videos. Imagine searching on YouTube not by title, but by asking for the specific scene or content you’re looking for!

Built as an MVP: Everything Runs Locally

VideoAI is currently an MVP. Everything is running locally on my machine—from the AI models that generate captions and embeddings, to the storage of video data in the vector database.

Final Thoughts

I’ve had an absolute blast building VideoAI, and I’m incredibly excited about its potential to transform how we interact with videos.

I hope you’re as excited about VideoAI as I am. I’d love to hear your thoughts, feedback, and ideas. Thank you for taking the time to explore this with me!

• 24/9/2024 - Added best case and average case time complexity

Introduction

I recently had a chance to tinker with some aspect of sudoku that I hadn’t done before; aspects such as creating and solving a sudoku puzzle programmatically. This blog encompasses the latter part - solving a sudoku programmatically. More specifically, the blog is going to focus on time complexity of the solver’s algorithm and and provide empirical measurements of the time required for various grid sizes.

What is Sudoku?

According to Wikipedia,

Sudoku is a logic-based, combinatorial number-placement puzzle. In classic Sudoku, the objective is to fill a 9 × 9 grid with digits so that each column, each row, and each of the nine 3 × 3 subgrids that compose the grid contains all of the digits from 1 to 9.

As mentioned, classically, the game of sudoku involves a square grid of 9×9 size. But it can be extended to larger board sizes of 16×16 or even up to 25×25 sized boards.

// A typical sudoku puzzle
+-------+-------+-------+
| . 8 . | . 7 . | . . 3 |
| . . . | . . . | . 8 9 |
| . . . | 6 . . | . 1 . |
+-------+-------+-------+
| . . . | . . . | . 7 . |
| . . . | . . 5 | . . 6 |
| 9 7 . | 8 6 . | . . 2 |
+-------+-------+-------+
| 3 . 6 | 1 5 . | 9 . . |
| 5 . . | . . 6 | . . . |
| . . . | . 4 7 | . . . |
+-------+-------+-------+

Algorithm for Solving Sudoku

The algorithm uses a backtracking approach for solving a sudoku puzzle. Backtracking is a method used to solve problems by trying out different solutions step by step. If it finds that a particular choice doesn't work, it goes back and tries a different option. For Sudoku, this means filling in one cell at a time and checking if each number is valid before moving on to the next cell. If a choice leads to a dead end, it "backs up" to try another number.

const solve = (board: Board) => {
  for (let i = 0; i < board.length; i++) {
    for (let j = 0; j < board.length; j++) {
      if (board[i][j] === 0) {
        for (let num = 1; num < board.length + 1; num++) {
          if (isValid(board, i, j, num)) {
            board[i][j] = num;
            if (solve(board)) return true;
            else board[i][j] = 0;
          }
        }
        return false;
      }
    }
  }
  return true;
};

/**
 * Checks if the current number placement satifies all sudoku rules
 */
const isValid = (board: Board, row: number, col: number, num: number) => {
  for (let i = 0; i < board.length; i++) {
    if (board[row][i] === num) return false;
    if (board[i][col] === num) return false;
  }

  const subgridSize = Math.sqrt(board.length);
  const rowStart = row - Math.trunc(row % subgridSize);
  const colStart = col - Math.trunc(col % subgridSize);

  for (let i = 0; i < subgridSize; i++) {
    for (let j = 0; j < subgridSize; j++) {
      if (board[rowStart + i][colStart + j] === num) return false;
    }
  }

  return true;
};

Here’s a simple breakdown of how the solver works:

1. Loop Through the Board: The function starts by checking every cell in the Sudoku board using two nested loops. The outer loop iterates through each row, and the inner loop iterates through each column. That means the board is looped over from left to right and top to bottom.

2. Find an Empty Cell: If it encounters an empty cell, it will try to fill it with numbers from 1 to 𝑁 (where 𝑁 is the size of the board).

3. Check Validity: For each number, it calls the isValid function to check if placing that number in the current cell is allowed according to Sudoku rules.

4. Recursive Call: If the number is valid, it places the number in the cell and recursively calls solve with the newly filled board to try to fill the next cell. If the recursive call returns true, it means the puzzle is solved.

5. Backtrack if Necessary: If placing the number doesn’t lead to a solution (the recursive call returns false), it resets the cell to 0 (indicating empty cell) and tries the next number.

6. Return True When Solved: If all cells are filled correctly, the function returns true.

The isValid Function

This function checks if placing a number in a specific cell follows Sudoku rules:

1. Row and Column Check: It first checks if the number already exists in the same row or column. If it does, the function returns false.

2. Subgrid Check: It calculates which subgrid the cell belongs to and checks all cells in that subgrid to see if the number is already present. If it is, the function returns false.

If the number passes all checks (not found in the row, column, or subgrid), the function returns true, indicating it can be placed there.

Time Complexity Analysis

1. Board size: If board size is 𝑁. Then a sudoku board has 𝑁² cells.

2. Empty Cells: In the worst case, the algorithm may need to fill all the cells, i.e., 𝑁² cells.

3. Number placement attempts: For each empty cell, we may attempt to place numbers from 1 to 𝑁. This means we have up to 𝑁 attempts for each empty cell.

4. Validity Checks: The isValid function performs checks across a row, column and a subgrid of the current cell. The size of row and column are 𝑁 and size of the subgrid is √𝑁 * √𝑁 = 𝑁. That means it runs for 3𝑁 ≈ 𝑁; resulting in a total validity check complexity of O(𝑁).

5. Recursive Nature: The backtracking approach can lead to a branching factor of 𝑁, as for every empty cell, the algorithm may have explore placing each of the 𝑁 numbers.

Overall Time Complexity

Worst Case

Putting this together gives us:

$$N^{N*N}= N^{N^2}$$

This is because we potentially explore each cell 𝑁² and for each cell, try up to 𝑁 numbers. This is the worst case time complexity.

Best Case

The best-case time complexity of the backtracking algorithm for solving Sudoku can occur when the puzzle is almost solved, with only a few empty cells to fill, and the first attempts at placing numbers are successful without much backtracking. In this scenario, the best-case complexity would be significantly lower than the worst case.

That means, the best-case time complexity would be O(𝑁²), where the algorithm only has to check each empty cell once and fill it correctly on the first attempt. But it’s important to note that this best-case scenario is highly optimistic.

Average Case

The average-case time complexity of a backtracking algorithm for solving Sudoku is challenging to define precisely, as it depends on factors such as the puzzle's structure, the number of pre-filled cells, and how effectively the algorithm prunes the search space.

Due to constraint propagation and early pruning of the search space, the algorithm doesn't need to explore every possible board configuration. A reasonable estimate for the average case is

$$O(K^{N^2})$$

• K is a constant less than N, reflecting that not all numbers are tested in every cell.

• N² is the total number of cells in the grid.

Benchmarking

To better understand the practical implications of this time complexity, I conducted empirical measurements by solving Sudoku puzzles of different sizes and recording the time taken.

The setup involves generating puzzles of varying sizes of 9×9, 16×16 and 25×25 using a puzzle generator and solving these puzzles using the algorithm mentioned above and timing each solve.

Results

The reason the iteration count is odd because the puzzle generator creates unsolvable puzzles which are omitted.

The algorithm took forever to solve a 25×25 puzzle. Hence, it is not mentioned in the data above.

Conclusion

In this exploration of the backtracking algorithm for solving Sudoku puzzles, we demonstrated how it fills cells one at a time, backtracking when necessary. While this method is effective for smaller grids, its time complexity of N^{N^2} makes it impractical for larger sizes. The empirical measurements show that smaller puzzles can be solved relatively quickly, whereas larger ones, such as 25×25 grids, present significant challenges.

The code used for the demo above can be found here.

Thank you!

As a committee member of a large housing society, our group chats are flooded with messages every day. It became nearly impossible to stay on top of everything without spending hours sifting through the conversations. This is the problem ConvoDigest solves—a local-first solution that enables me (and others) to summarize and query long, unstructured group chats while keeping the data entirely private.

The Problem

In large communities, group chats are a vital means of communication, but the sheer volume of messages—often scattered across multiple topics—makes it easy to lose track of important information. From minor maintenance issues to significant resident concerns, these chats provide valuable insights, but accessing that information amidst the clutter is challenging.

That’s where ConvoDigest comes in. It transforms raw conversations into actionable insights by generating summaries, identifying key points, and answering specific questions. For example, I can now ask, “What were the main issues discussed this week?” or “How many times was a certain issue mentioned?”—and get precise, contextually aware responses.

A Local-First, Privacy-Focused Solution

Privacy is a significant concern for many people, particularly when it comes to sensitive chat data. I knew that offloading this data to external servers would be off-putting for most people. Instead, ConvoDigest processes everything locally on your device, ensuring that your data never leaves your control.

How It Works

At its core, ConvoDigest uses a combination of Vectra (a vector database) and AI models like LLaMA 3.1 (7B parameters) via Ollama to process and analyze chat data. By creating embeddings, the app can understand the content better and provide meaningful responses.

The frontend and backend were built using Node.js, Express, and React, inspired by the minimal design of ChatGPT to keep the interface simple. Users can upload their WhatsApp chat data, and the app processes it locally, turning it into searchable summaries and insights.

Challenges

Embedding Nuanced Conversations: WhatsApp chats are typically unstructured, with abrupt topic changes, slang, and even code-mixed content. Properly embedding these into a vector database required refining the embedding process to capture the meaning behind the words.

Contextual Chunking: Breaking long chats into manageable chunks for embedding meant dealing with context loss across chunks.

Temporal and Cross-Chunk Dependencies: Chat conversations are often temporal in nature, meaning the sequence and timing of messages matter. Capturing these subtleties using static embeddings is a significant technical hurdle.

Non-Textual Data: Conversations often contain non-textual elements like images, videos, and PDFs. Although these are not processed by the app yet, handling mixed media will be an important step in future iterations.

Future plans

At this stage, ConvoDigest is an MVP, and there’s much more I want to explore. One of the immediate next steps is to containerize the app so users can easily deploy it with a single Docker command. This would make installation and setup far simpler.

I’m also excited about experimenting with more advanced embeddings techniques and possibly integrating other LLMs to further improve the app’s accuracy and performance. Refining how context is handled across conversations and exploring ways to incorporate non-textual data into the summarization process are key areas I’ll be focusing on moving forward.

Final Thoughts

Building ConvoDigest has been a rewarding journey that allowed me to bridge AI concepts like LLMs, RAG, and embeddings with a practical a use case. It’s been a deep dive into how these technologies can simplify complex, overwhelming data—in this case, lengthy group chats—and transform it into something much more digestible and actionable.

I’m looking forward to improving the app and helping others with similar issues in the future.

Check out the app here.

For the past few months, I’ve had the incredible opportunity to intern with the Aerospace Division at Eaton, an experience that not only shaped my professional skills but also gave me invaluable exposure to working alongside some of the brightest minds in the industry. Here's a glimpse into my journey, from the technical challenges I tackled to the dynamic teamwork that made it all possible.

The Work I Did 👨‍💻

As part of Eaton’s Aerospace Division, I was worked on the development of an in-house automation tool called AReG. Built using Python for business logic and Qt for the graphical interface, this tool automates the preparation of Test Plans for Fluid Conveyance products—a highly critical process in the aerospace sector where precision and reliability are paramount.

The aerospace industry, by its very nature, demands zero error tolerance, and every component undergoes rigorous testing to meet industry standards. AReG revolutionizes this by automating the entire Test Plan preparation, potentially reducing the turnaround time by an astounding 90-95%. This automation not only increased efficiency but also contributed to the team's overall productivity and the division’s success in meeting tight deadlines.

Working on AReG required a deep understanding of aerospace product requirements, fluid conveyance standards, and testing protocols. I quickly adapted to the complexities of the industry, diving into high-level problem-solving with precision. I collaborated closely with senior engineers to refine the automation algorithms, ensuring that they were not only efficient but also adaptable to varying product requirements.

This project helped me sharpen my skills in both Python and Qt, and it was incredibly rewarding to develop an application with such a significant impact on business operations at an industry level. The insights I gained into automation, software development processes, and the aerospace domain are experiences I’ll carry forward into my career.

Experience with the Team 🚀

Working alongside Eaton’s highly talented and seasoned professionals, many of whom came from prestigious institutions like IITs and held advanced degrees, was an incredible experience. From the moment I joined, the team was welcoming and eager to share their knowledge. My direct collaboration with a Senior Engineer and Lead Engineer gave me hands-on learning and the chance to witness their problem-solving approaches firsthand.

What stood out to me was the balance the team maintained between hard work and a great work culture. We celebrated each other's successes and collaborated in an environment that fostered both professional and personal growth. Being part of such a close-knit and high-achieving group made the internship experience even more fulfilling.

My team at the celebration. I am on the extreme left!

This is us celebrating Independence Day at the office.

The Interview Process 👨‍🏫

I secured this opportunity through my college’s campus placement, where Eaton had come to recruit summer interns. The interview process was straightforward, consisting of a resume shortlisting followed by a technical round and an HR round.

The technical round was led by an engineering manager who created a calm and engaging environment right from the start. The 40-minute conversation was insightful and revolved around my projects and the possible contributions I could make to their team. We also discussed real-world engineering challenges, which helped me understand their expectations and gave me a chance to showcase my problem-solving skills.

I was thrilled when the results were announced the next day—I was selected!

Key Takeaways ✨

Throughout this internship, I learned how to solve complex problems effectively and gained deep insight into how senior engineers approach challenges. My ability to adapt and apply theoretical knowledge in real-world settings grew exponentially. I also gained firsthand exposure to how leadership teams at the engineering manager level strategize and execute on timelines for critical projects.

Being able to collaborate with engineers from different teams expanded my understanding of various technical domains and processes. The entire experience has made me more confident in my skills, whether it's technical problem-solving, communication, or teamwork.

Conclusion 🙌

This internship has been one of the most enriching experiences of my career so far. From building a high-impact automation tool to working alongside a phenomenal team of engineers, every moment at Eaton was filled with learning and growth. My exit interview was a gratifying close to the journey, with my manager appreciating my dedication, technical contributions, and adaptability.

If you have any questions or want to discuss more about my experience, feel free to reach out!

I am Kedar. I am a full-stack web developer. I started learning and building with React in March 2022.

Siddhi is also a full-stack web developer. She has been building projects for hackathons since last year.

Both of us are students in senior year.

Together, we have formed a team for Hashnode x PlanetScale hackathon! 🔥

Inspiration

Siddhi and I are entering the senior year of college; so, we have to start preparing for interviews and applying to companies for jobs and internships. As we started preparing, it seemed that everything was all over the place, 👇

• we could not keep track of our notes; technical questions gathered from previous interview experiences of others on the internet and our solutions to it.
• we also missed preparing some common behavioral questions too.
• and keeping track of people who would give referrals and a tailor-made referral message for different companies.
• we also needed to revise certain conceptual/theoretical questions for the interview.

Hence, was born the Get Interview Ready app!

Introducing Get Interview Ready! 🎯

Get Interview Ready is the one-stop solution for helping you with all aspects of interview preparation, from practicing technical and behavioral questions to helping you manage your referral network, and so much more! Let's find out how through its features 🌟👇

Behavioral Questions

What is your approach to handling project delays?

Ever been asked such a question at an interview? It is a typical example of a behavioral question that is asked in 99.99% of the interviews. Although there are no single correct answers to these types of questions, it helps to prepare in advance, so that you will be able to answer this with confidence and without any hesitation during the live interview where one might usually feel under pressure. The app comes with a set of most commonly asked behavioral questions which you can prepare for, and also add your own to the list!

Technical Questions

Ever spent hours, solving an excruciatingly hard technical question only to lose the notes and its solution when needed the most? We’ve been there, and we know how it feels to find notes and solutions scrambled all over the place during revision (on different websites such as Repl, Codesandbox or Codepen). Even the handwritten notes sometimes go missing!

Hence, we introduce the Technical Questions feature ✨.

You can add all the questions in one place and provide an embed link from either Codepen, Codesandbox, Repl or GitHub Gist, for adding a solution. Along with that, there's also a markdown editor which you can use to write important notes and steps for solving the problem. This feature comes in handy while solving and keeping track of questions gotten from previous interview experiences on the internet!

Project Questions

Ever been caught off guard while answering questions related to your own projects? This is common as one is likely to feel stressed or pressurized in an interview situation, because of that, we hesitate to answer without exuberating much confidence. This can foil all the effort that we put into building projects!

Hence, we introduce the Project Questions feature ✨.

Project Questions help you prepare a few sets of common questions regarding projects which are ordinarily repeated in interviews. In this feature, you can add your projects, tag them with the tech stack that you used, answer a few common questions regarding them, and also add your own questions which you feel might be relevant! This feature comes in handy to keep a note of questions such as “What challenges did you face while building this project?” Preparing this beforehand can greatly go in your favor in interviews!

Conceptual Questions

Ever found yourself scrambling to answer questions that need memorization for the most part? Such conceptual/theoretical questions are definitely asked in interviews! To help you prepare for such questions;

We introduce Flash Cards ✨

Flash cards refer to cards that have a question on one side and its answer on the other side. The Flash Cards feature has the same functionality, wherein you can create a deck of cards for different subjects or topics and add multiple cards in one deck. You can practice all the info in these decks of cards by taking a test in which the questions are displayed in random order!

Dream Companies

Ever found it hard to recollect the person that you met on LinkedIn who could possibly give you a good referral? Referrals help us get interview opportunities with much ease. Along with that, having a rough idea of what companies you are aiming for and why helps build clarity while forming messages/emails asking for referrals. It’s important to manage and keep track of these referrals.

Hence, we introduce Dream Companies ✨

Dream Companies feature lets you add companies that you are targeting. For every dream company of yours, you can write a tailor-made message stating your intent and relevant skillset, asking for referrals. Along with that, you can add a list of people you might give you referrals along with their links such as LinkedIn, Twitter, etc. For every person that you add, you can keep a track of whether you have contacted them or not.

Dashboard Analysis

The Dashboard is what you are greeted with when you first login into the app. It's full of cards, and these cards convey information to stay motivated in your interview preparation journey

• Flash Card Stats card shows a graph of the scores of tests that you have taken in terms of % over the last 7 days.

• A pie chart reflects how many behavioral questions you have practiced out of the recommended ones.

• The other cards show the number of dream companies and project questions you’ve added and the number of people you’ve contacted for referrals.

Technologies and Tools 🛠

• React.js for building the frontend
• Chart.js for data visualization
• PlanetScale for the database 🌟
• Node.js with Express.js for building the backend

Building get Interview Ready 👩‍🏭

Planning 🌱

We used Notion to plan the project, and its UI and to write our daily to-dos. While planning, we divided the entire work into 2 parts; UI design and implementation. Further, the implementation part was divided into different features. We made a list of all the possible tasks that need to be done to build our planned features.

Designing 🎨

We used Excalidraw for designing the UI for our app. It is a simple tool to design the wireframes of the app.

• The initial design of the app looked like this👇

• The database design looked like this 👇

• The backend API design looked like this 👇

Building 👩‍💻

We created an organization on GitHub for the app. The app is logically divided into 2 repos in the organization, viz. frontend, and backend. After our feature requirements and UI designs were ready, we got to building 💪 🛠️.

We divided the features that needed to be built among us and worked asynchronously. On completion of every feature, we would review each other’s PR and merge it in the repo. For the backend database, we used PlanetScale ✨. The backend server is hosted on Heroku, and it is built using Node and Express! The main frontend app is built using React and hosted on Vercel.

Challenges we faced ☠

The main all-encompassing challenge itself was taking on a project with a good deal of features, that needed to be completed in a week’s time.

Since the app is big, we had difficulties structuring the frontend app until we came up with a good and manageable folder structure.

Also, we pondered a lot on making the UI as intuitive and as simple to use as possible. Hence, we came up with multiple solutions, and choosing one out of them seemed difficult.

What’s next ✨

We are looking forward to adding more features to our app:

• Audio Recording answers to questions
• Listening to the recorded answers to revise
• Transcribing audio to text

Useful links 🔗

• App Link
• GitHub Repo for frontend
• GitHub Repo for backend

That’s all folks 👋

We would like to thank PlanetScale for providing such excellent documentation and Q/A community!

That's a wrap. We hope that Get Interview Ready will help you nail your interviews! 🎯

Stoked to present to you, my submission for Auth0 x Hashnode Hackathon! ⚡

Introduction

Introducing PAViC, a simple, easy-to-use and a hassle-free app for making fast and secure payments using your mobile phone, powered by blockchain. It uses its own cryptocurrency called Vitcoin (named after my alma mater VIT, Pune.😉🏫). Based on a completely decentralized platform, PAViC stores all your personal and sensitive financial data in a distributed fashion with strict access controls. The app makes sure that it's only you who has the right to access to your sensitive data and nobody else. There is no central entity in control, hence, gone are the days of abuse of your personal information. Read on to find out more!

TL; DR

Things you can do on PAViC:

App Walkthrough

• One click signup powered by Auth0⚡. Create free account!

• Get a reward on signup! 💰

• Make hassle free payments. 💸

• Mine transactions and earn rewards! ✨

• View your transaction history. 📃

What's more?

• Powered by Blockchain Tech!
• 100% secure, with privacy at its core! 💯
• Built for the community, powered by the community! No single person in-charge!

What are the objectives of the app?

• Build a decentralized cryptocurrency network and maintain a distributed database on mobile devices.

A decentralized mobile network illustrated.

The first objective is to build a network of mobile devices which will be able to communicate with each other in a decentralized fashion. The transactions (ledger) and blockchain data would be distributed and stored with every mobile device in a decentralized manner. The transactions data contain the amount and the parties involved in that transaction, and every transaction is associated with a specific block on the blockchain.

• Enable payment transactions and implement a reward system. 💰

Through this decentralized channel, any mobile device would be able to make a payment to another mobile device on the network. We need to verify these transactions to maintain the integrity in the network. As there is no central third party involved to verify (mediate) any transaction, this job of verification is performed by any mobile device on the network itself. For this job, that user is rewarded with a sum.

How PAViC Works? 💡

PAViC system is based on a network of mobile devices. These mobile devices have the ability to communicate with one another. Every time a user wants to make a payment, he/she has to enter the details in the app such as the name of the recipient and the amount, and this transaction data gets broadcasted to all other mobile devices on the network, since, this is a decentralized financial system. But the other mobile devices would not be able to see the information contained in this broadcast, hence, privacy is preserved!

A transaction getting broadcasted.

Every mobile device stores the transaction data in a 'pending transaction' buffer. Mind you, the payment is not complete at this point. The money has not exchanged hands yet. The transaction in this buffer has to be verified (mined). This verification task can be done by any user on the network, even the person who's made the payment in the first place! This can be accomplished by simply tapping a button in the app, which runs a verification algorithm behind the scenes. After the verification is done, the transaction gets completed, the money exchanges hands and the user responsible for verifying pending transactions gets a reward!

How I built this app? 👨🏻‍🔧

This is my first app! My first time ever building an end-to-end product! The journey was full of challenges, setbacks, drowning in docs and rewarding experiences at the end! Here's a brief summary of my journey...

Planning Phase 📝

As I had figured out the main objectives, I needed to plan a way to implement them into the app. I divided the whole development procedure into phases. Firstly, I worked on system design and then proceeded onto the implementation phase. Trello was my best friend through this whole procedure, it helped me keep a track of everything and stay organized.

Design Phase 👨🏻‍🏫

Database Design

There are 4 main entities in put system, viz., users, transactions, pending transaction and blocks. I made a table for each of the entity. I chose to go with a SQL database for this one. This is the schema design of the database:

UI Design

The design part of the app was the toughest for me to figure out as I lack the knack for coming up up good design ideas. I looked for inspiration and templates all over the internet, especially on dribbble. I wanted the design to be very minimal, intuitive and dead easy to use and figure out. This process also consists of trying to come up with a color scheme. The proven way was to go for Tailwind CSS color palette. How can you go wrong, eh?😉 I went with the blue palette for mainly one reason. My app comes under finance category and the color blue signifies freedom, confidence and trust. These characteristics go perfectly together with what a cryptocurrency is supposed to be. So everything just fell in place together perfectly!

I used Excalidraw to create wireframes of the screens in the app. The main app consists of 3 screens:

Implementation 🛠️

Tech Stack 💻

• React Native - Framework for mobile app development 📱🛠
• Auth0 - One stop for all your User Authentication needs! 🛡️🔐
• SQLite3 - The deployed and trusted local database for mobile ⚡
• Socket.io & Node.js - For communication between mobile devices

Authentication 🛡️

Auth0 provides user authentication API with docs and guides that's dead easy to follow and implement. For someone like me, who's not familiar with the ins and outs of configuring their own custom authentication flow greatly appreciates this. 😉

It provides a great feature called Universal Login, which comes with its own login infrastructure and a whole set of features. Hence, I did not need to create my own login page in the app. So every time a user wants to sign-in, he/she is directed to Auth0's secure login page. It has a clean and customizable UI, in which I configured my own logo. Auth0 made integrating social login providers such as Google superbly easy. There's a whole host of features that I have yet to tinker with such as Multi-factor Authentication and Passwordless Connections. Definitely in the future some time...

Communication 🌐

The channel through which the mobile devices communicate and share data is created using socket.io.

Challenges that I faced 🥶

I worked with JavaScript and React Native for the first time. Almost everything seemed challenging, and the initial period of development was full of rookie mistakes. Here's a highlight of a few of them:

• I'm not awfully fluent when it comes to writing SQL queries. I ended up making a good deal of mistakes at the beginning and, in turn, created so many bugs. So I had to go back to the docs again to rectify these mistakes. 😛
• Configuring the event listeners in the socket.io was a little tough for me in the beginning. But with their docs and stackoverflow to the rescue, I had it figured out in no time.
• Certain features such as calculating a user's balance or verifying transactions are asynchronous. Hence, I had to wrap my head around the concepts of Promises and async/await to get them working correctly.

What's next? ✨

• Phone book like interface for quickly selecting contacts while making payments.
• QR Code Scanning for quick transactions.
• Support for other cryptocurrencies.
• A web-app for browser for accessing your account. (Will offer me a chance to work with React.js as well😉)

Useful Links 🔗

GitHub Repositories

• Mobile App Repo Link
• Communication Channel Repo Link

App Store Download Links ✨✨

• EXPO
• Play Store

Winding up...

Thanks a ton for making it till here. 🙌🏻 I would absolutely love to hear what you think about PAViC, so let me know down in the comment section and while you are at it, also drop a like. 😉