DEV Community: Saumyajit Purakayastha

Creating a Cluster on MongoDB Atlas

Saumyajit Purakayastha — Mon, 06 Oct 2025 07:31:55 +0000

MongoDB Atlas is a fully managed cloud database service that simplifies the deployment, management, and scaling of MongoDB clusters. Whether you're building a small prototype or a production-grade application, Atlas provides a user-friendly interface and robust features to get you started quickly. This polished guide walks you through creating a cluster on MongoDB Atlas, with detailed steps and practical tips to ensure a smooth setup.

Prerequisites

Before you begin, ensure you have:

A MongoDB Atlas account (sign up at mongodb.com).
A valid email address and, optionally, a payment method for paid tiers (a free tier is available for testing).
Basic familiarity with MongoDB concepts, such as collections and documents.

Step-by-Step Guide

1. Log in to MongoDB Atlas

Navigate to the MongoDB Atlas website and sign in with your credentials. If you’re new to Atlas, click Sign Up, provide your email, and follow the prompts to create an account. Verify your email to activate your account.

2. Create a New Project

Upon logging in, you’ll arrive at the Atlas dashboard. Click New Project in the top-left corner. Enter a descriptive project name, such as "MyFirstCluster," to organize your databases. Click Next to proceed. Optionally, invite team members to collaborate or click Create Project to continue solo.

3. Build a Database

In the project dashboard, locate and click Build a Database (or Create a Cluster). Atlas offers three cluster types:

Shared: Free tier, perfect for learning or small projects.
Dedicated: For production workloads with customizable resources.
Serverless: Pay-per-use for flexible scaling.

For this guide, select the Shared (free) tier and click Create. This tier, also known as the M0 Sandbox, provides 512 MB of storage, ideal for experimentation.

4. Configure Cluster Settings

Customize your cluster with the following settings:

Cloud Provider & Region: Select a provider (AWS, Google Cloud, or Azure) and a region close to your target audience to minimize latency. For example, choose AWS’s us-east-1 for North American users.
Cluster Tier: Confirm M0 Sandbox for the free tier.
Cluster Name: Assign a name like "TestCluster" for easy identification.
Additional Settings: Retain defaults for MongoDB version and backup options, as backups are unavailable in the free tier.

Review the settings and click Create Deployment. Cluster creation typically takes 3–5 minutes.

5. Create a Database User

While the cluster is provisioning, set up access. Click Database Access in the left menu, then Add New Database User in the pop-up. Create a username (e.g., "dbUser") and a strong password. Assign the Read and Write to any database role for full access. Save the credentials securely, as they’re needed for connecting to the cluster.

6. Configure Network Access

To allow connections to your cluster, click Network Access in the left menu, then Add IP Address. For testing, select Allow Access from Anywhere (0.0.0.0/0). For production, specify your application’s IP or use VPC peering for enhanced security. Save the settings.

7. Choose a Connection Method

Once the cluster is ready, click Connect on the cluster dashboard. Atlas offers several connection options:

MongoDB Shell: Copy the connection string for use in the MongoDB shell.
Application: Select your programming language (e.g., Node.js, Python) and use the provided code snippet.
MongoDB Compass: Download and install MongoDB Compass, then paste the connection string.

Replace <password> in the connection string with your database user’s password. Test the connection to ensure it works.

8. Add a New Database to Your Cluster

Navigate to the Collections tab in your cluster dashboard and click Create Database. Enter a database name (e.g., "myDatabase") and a collection name (e.g., "myCollection"). This creates a storage structure for your data.

9. Insert a New Document

In the Collections tab, select your database and collection, then click Insert Document. Add a sample document manually or use the following JSON format:

{
  "_id": {
    "$oid": "68e36dcb2a6c4114653f4f29"
  },
  "name": "Saumyajit"
}

Click Insert to save the document. Verify it appears in the collection.

10. Test Your Setup

To confirm everything is working, connect via your preferred method (e.g., MongoDB Compass or a code snippet) and run a query. For example, in the MongoDB shell or a Node.js application, insert and retrieve a document:

db.myCollection.insertOne({ name: "Test", date: new Date() });
db.myCollection.findOne();

If the document is returned, your cluster is fully operational.

Best Practices

Security: Restrict network access to specific IPs in production to prevent unauthorized access.
Monitoring: Use Atlas’s built-in monitoring tools to track performance metrics like CPU usage and query latency.
Backups: For critical applications, upgrade to a paid tier to enable automated backups and point-in-time recovery.
Scaling: Monitor storage and performance needs. Upgrade to a higher tier (e.g., M10 or above) for production workloads.

Conclusion

Setting up a MongoDB Atlas cluster is a quick and intuitive process. Thanks to @santhoshnc for introducing to this world of NoSQL Databases.

For more information, check the MongoDB Atlas documentation.

REST > React? Why Blockchain Devs Should Care About the Basics

Saumyajit Purakayastha — Fri, 18 Apr 2025 18:11:33 +0000

In a world where a new JavaScript framework seems to spawn every fortnight and the vibe coding epidemic lures fresh devs into the abyss of aesthetic over architecture, one silent champion remains—the humble API. For blockchain developers, understanding REST isn’t just some dusty legacy skill — it’s a foundational pillar that can define the success or scalability of your entire dApp.

Think of your dApp as a high-performance sports car. React? That’s the sleek bodywork, the shiny paint job. REST? That’s the engine. You can’t win a race with just a cool paint job — you need power under the hood. And when your frontend can't talk to your backend reliably, it doesn't matter how many Tailwind classes you sprinkled in.

Why It Matters

REST and HTTP power the entire internet—and Web3 didn't escape that. Your dApp talks to blockchain nodes, RPC endpoints, APIs, IPFS gateways, auth servers, and maybe even a backend you forgot was running.

Whether you’re hitting an Ethereum node via Infura, uploading assets to IPFS via Pinata, or verifying off-chain data with Chainlink, RESTful communication is everywhere.

And let’s be real: Web3 is not 100% on-chain. It never was. And probably won’t be (unless your users enjoy waiting 12 seconds for a response).

Understanding REST and HTTP gives you superpowers:

Debug failed RPC requests without having to Google error codes.
Build your own tooling and services.
Integrate off-chain components with actual confidence.

Core Concepts to Master

There are some fundamental concepts of REST you must be familiar with before you start calling the endpoints with your favorite tools:

HTTP Methods:
- GET - Fetch data (e.g., get your wallet balance)
- POST - Submit data (e.g., send a transaction or upload a file)
- PUT - Update existing data
- DELETE - Remove data (be careful, obviously)
Headers & Status Codes: Understand Authorization, Content-Type, Accept, and what a 403, 500, or 201 Created means. These matter when your fetch() call mysteriously fails in your dApp.
RESTful Principles: Stateless interactions, predictable URLs, and treating everything as a resource. Helps when you’re building your own API gateway or backend service for metadata storage.
JSON Anatomy: Know what a JSON body looks like. Practice reading and writing them. You’ll debug faster and build integrations cleaner.

📌 HTTP Methods Example (with `curl` and JavaScript)

# GET example: Fetch a token balance (dummy endpoint)
curl -X GET "https://api.example.com/balance?address=0x123" -H "Accept: application/json"

# POST example: Submit NFT metadata
curl -X POST "http://localhost:3000/mint" \
-H "Content-Type: application/json" \
-d '{"name": "Space Ape", "image": "ipfs://Qm..."}'

// Equivalent in JavaScript (e.g., in a React dApp)
fetch("http://localhost:3000/mint", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    name: "Space Ape",
    image: "ipfs://Qm...",
  }),
})
  .then((res) => res.json())
  .then((data) => console.log("Mint response:", data));

Real-World Examples related to Web3

Let’s bring REST into the blockchain trenches:

Token Balances with Etherscan API

Hit https://api.etherscan.io/api?module=account&action=tokenbalance&...

→ GET request, returns JSON. Simple, useful, RESTful.
IPFS Uploads via Pinata or Moralis

Uploading files? You’re POSTing to a REST endpoint with a Content-Type: multipart/form-data header. Knowing this helps you automate uploads and debug when something breaks.
Wallet Interactions via REST

WalletConnect and some mobile wallets expose HTTP APIs for session management. MetaMask and similar extensions use background messaging patterns that, while not strictly REST, follow similar request/response paradigms.

📌 IPFS Upload Example with Pinata (Node.js)

const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");

const form = new FormData();
form.append("file", fs.createReadStream("./nft.png"));

axios.post("https://api.pinata.cloud/pinning/pinFileToIPFS", form, {
  maxBodyLength: Infinity,
  headers: {
    ...form.getHeaders(),
    pinata_api_key: "your_api_key",
    pinata_secret_api_key: "your_secret",
  },
})
.then(res => console.log("File IPFS Hash:", res.data.IpfsHash))
.catch(err => console.error("Upload failed:", err));

How This Helps in Web3 Projects

Debugging becomes easier: Instead of praying to the dev gods when a fetch fails, you can actually read the response headers and fix it.
Cleaner Integrations: Knowing how to structure a request or parse a response means less guesswork, less spaghetti code, and fewer broken dApps.
Architectural Clarity: You’ll actually understand how your dApp talks to the backend, the blockchain, and anything in between.

Resources

Use API Clients:
- Learn to love Postman or Insomnia. They’re like Remix IDE, but for APIs—making requests, inspecting responses, and debugging is a breeze. Bonus: Chain them into CI workflows later.
Mini Challenges:
- Use your favorite programming language to build a tiny REST API: GET /hello returns { message: "Hello, Blockchain!" }.
- Use curl to POST data to your local server and log it.

🚀 Final Thought

Before you dive back into your Solidity scripts or spin up another dApp UI, take a moment to master the basics. REST isn’t “old school”—it’s foundational. The best blockchain developers aren’t just smart contract ninjas—they’re full-stack warriors who can debug an API call just as easily as they can deploy to mainnet. So, here’s your mission: build a mini REST API, ping it with curl, and understand what’s flowing under the hood. Because if you truly get how the web works, you’ll build Web3 that actually works.

Footnotes:

Cover image by Douglas Lopes on Unsplash
Etherscan API: https://docs.etherscan.io/
Pinata API: https://docs.pinata.cloud/api-reference/introduction
Postman API platform: https://www.postman.com
For more on REST in blockchain, see: https://blog.thirdweb.com/what-a-blockchain-api-is-and-how-to-use-it/

Hey Dad, Let’s Talk About the Future of Tech!

Saumyajit Purakayastha — Mon, 10 Mar 2025 18:58:01 +0000

This is a submission for the Future Writing Challenge: How Technology Is Changing Things.

Hey Dad,

Before you scold me for not calling you all week—I’ve got some new tech to geek out about! And trust me, you’re going to love this one. 😁

Now, don’t worry, I won’t bore you with lines of code (though I know you’d appreciate a well-structured C# snippet). Instead, I want to talk about the bigger picture—how tech is evolving and what it might mean for both of us.

🪙 Money Without Banks?

You've always been the organized kind—income gets deposited, bills get paid, and money stays safe in the bank. Simple, right?

But what if I told you that in the future, banks might not even be necessary?

Now, before you call me out for preaching Bitcoin again (and for nagging you about not buying it when it was dirt cheap—you should've 😒), hear me out.

With recent advancements in blockchain and cryptocurrencies, we’re moving toward a world where people can send money instantly, without needing a middleman.

I know what you’re thinking: “But crypto is volatile, and banks provide security!” Fair point. But even traditional banks are experimenting with digital currencies, and blockchain isn’t just about money—it’s about secure transactions, digital contracts, and even ownership records.

🤖 AI: Your Upcoming Junior Programmer?

You've been developing clear, efficient C# code for years. However, what if I told you that AI is also becoming increasingly proficient at that? Developers are already writing code more quickly thanks to tools like GitHub Copilot, which can recommend entire functions from a single comment.

Will coders be replaced by AI? Not at all. It's more akin to having an excessively enthusiastic intern who makes suggestions, some of which are excellent and others of which are totally incorrect. Although AI is excellent at automating tedious coding jobs, it still lacks creativity, insight for solving problems, and the capacity to debug its own gibberish.

But let's face it, wouldn't we have more time to concentrate on the actual problems if AI could take care of the tedious boilerplate?

🔐 Privacy: The Price of Convenience

Remember when we used to joke about tech companies listening to our conversations? Well… turns out, it’s not much of a joke anymore. Our data is the new currency, and companies are collecting, analyzing, and selling it at an insane rate.

With AI predicting our behavior and algorithms deciding what we see, it’s no surprise that ads seem to "magically" show up right after we talk about something. But with emerging threats like quantum computing, even our most secure encryption might become vulnerable in the future.

Does this mean we should go full "off-the-grid" mode? Not necessarily. But being mindful of what data we share and using strong security practices is going to be more important than ever.

💬 How Tech is Changing Us

Beyond all the cool innovations, technology is reshaping how we interact—and not always for the better.

👥 Relationships: We used to call each other. Now, it’s mostly texts, voice notes, and quick emoji reactions.

💼 Jobs: Automation is replacing repetitive tasks, but it’s also creating new jobs that didn’t exist a decade ago.

🏛 Truth & Misinformation: AI-generated content is so realistic now that it’s getting harder to tell fact from fiction. Deepfake videos, fake news, and AI-written articles can easily spread misinformation.

🚀 What’s Next?

The world is changing fast, and we can either adapt and ride the wave or ignore it and get left behind.

🔹 Stay curious—There’s always something new to learn.
🔹 Stay skeptical—Not everything on the internet is true (even if AI says it is).
🔹 Stay secure—Privacy matters, even if it’s inconvenient.

The way I see it, technology is neither good nor bad—it’s just a tool. How we use it is what truly matters.

So, Dad, what do you think? Are we heading toward a future of endless possibilities, or are we just writing more bugs for AI to fix?

Let’s talk soon—I promise not to bring up another blockchain rant (maybe). 😉

—Your Son

Sam

Additional Prize Categories

Ripple Effects

Context

I usually geek out about tech with my dad, who's a senior .NET developer. So, I thought—why not turn one of our usual discussions into a letter dedicated to him?

Thanks for reading! Please feel free to leave your comments below 😁

Python Guide: Credit Card Number Validation Using Luhn's Algorithm

Saumyajit Purakayastha — Sun, 09 Jun 2024 05:04:44 +0000

Hey, it's me, Silver, and today we are going to build a simple program that validates credit card numbers using the Luhn algorithm. This is a practical project for anyone learning Python and looking to understand input validation, control flow, and basic algorithm implementation.

What is the Luhn Algorithm?

The Luhn algorithm, also known as the "modulus 10" or "mod 10" algorithm, is a simple checksum formula used to validate various identification numbers, such as credit card numbers. It was created by IBM scientist Hans Peter Luhn and is widely used today.

Let's take an example to ease our trouble:
Consider the test credit card number generated by PayPal: "4032038996592097".

The algorithm works as follows:

Starting from the rightmost digit, double every second digit.
If doubling a digit results in a number greater than 9, then add the digits to get a single-digit number (for example, 18: 1 + 8 = 9, 16: 1 + 6 = 7).
Now add all the numbers, touched and untouched, at even places and odd places.
If the total modulo 10 is equal to 0, the number is valid. We have got 80 here, so our card number is valid.

Let's translate this logic into a simple Python program. You can check out the final results on GitHub too.

Implementing the Luhn Algorithm in Python

Let's dive into the code. Below is a Python script that implements the Luhn algorithm to validate credit card numbers. Additionally, the script ensures that the input is at least a 15-digit number.

Why 15 digits, you say? That's the least number of digits a valid credit card can have. Most credit card companies issue credit cards with 16 digits, but there are some exceptions; for example, American Express issues cards with 15 digits.

Well, let's start.

def main():
    card_number = input("Enter credit card number: ").strip()
    if is_valid_card(card_number):
        print("Valid credit card number.")
    else:
        print("Invalid credit card number.")

def luhn_check(card_number):
    def digits_of(n):
        return [int(d) for d in str(n)]

    digits = digits_of(card_number)
    odd_digits = digits[-1::-2]
    even_digits = digits[-2::-2]
    checksum = sum(odd_digits)

    for d in even_digits:
        checksum += sum(digits_of(d * 2))

    return checksum % 10 == 0

def is_valid_card(card_number):
    if not card_number.isdigit() or len(card_number) < 15:
        return False
    return luhn_check(card_number)

if __name__ == "__main__":
    main()

How It Works

Input Validation: The is_valid_card function checks if the input is a string of at least 15 digits using card_number.isdigit() and len(card_number) >= 15.
Luhn Algorithm: The luhn_check function processes the digits using the Luhn algorithm:
- It splits the number into individual digits using the internal function digits_of.
- Then we create two separate lists of even_digits and odd_digits. We perform necessary operations using checksum on both the lists.
- Finally, we check if the total modulo 10 is 0.
Output: Based on the result of the Luhn check and the length validation, the program prints whether the credit card number is valid or not.

Running the Program

To run the program, follow these steps:

Copy the script into a file named cc-validator.py.
Open a terminal and navigate to the directory containing the script.
Run the script using Python:

python cc-validator.py

Conclusion

Congrats on building your own credit card number validator!

The Luhn algorithm is a powerful tool that showcases how simple mathematical rules can be applied to real-world problems. This project is part of a series of validation projects aimed at helping learners solidify their Python programming skills. You can check out similar validation projects here.

Thanks for reading! Feel free to share your thoughts below.

Footnotes:

GitHub Profile
Cover Photo by rupixen on Unsplash.

Bug Bounty Hunting 101: An Introduction for Beginners

Saumyajit Purakayastha — Wed, 29 May 2024 08:09:20 +0000

Introduction

Bug bounty hunting, as the name suggests, is an activity where you hunt for bugs (look for security vulnerabilities) in software applications, websites, and systems and report them to the company or organization running the bounty program.

In layman's terms, it's like being a digital detective who finds hidden weaknesses in code, helps improve security, and gets paid for it. Yep, you read that right. It's a legal way to earn money online using your hacking skills without the FBI knocking on your door.

How to Start?

Well, I'm going to give you a glimpse of how to become a bug bounty hunter, but for further details, you'll need to purchase my $999 course where you'll get generic information that’s available on the internet for free. 😶

Just kidding! I’m not a YouTuber. 🗣️

Anyway, please read the rest of this guide with patience, without simply scrolling away, and you might gain some new information and perhaps enlightenment. This guide will cover how to acquire knowledge using resources from the internet and books, and crucially, how to apply that knowledge practically at each step.

So, let's begin...

Step 1: Foundation in Computer Science and Networking

"Crawl before you walk."

Before you dive into the digital bug battlefield, remember: a solid grasp of computer science and networking basics is your armor. Rest assured, I've got you covered.

Online Resources:

CS50's Introduction to Computer Science (Harvard OCW)
Introduction to Networking (Khan Academy)

Recommended Book:

"Foundations of Information Security: A Straightforward Introduction" by Jason Andress: This book covers the basics of networking and introduces cryptographic principles which are crucial for understanding network security.

Key Concepts: Study IP addressing, DNS, TCP/IP, HTTP/HTTPS, firewalls, and VPNs.

Practice: Set up simple networking labs using tools like Cisco Packet Tracer or GNS3.

Step 2: Understand Web Technologies

“The Web as I envisaged it, we have not seen it yet. The future is still so much bigger than the past.” – Tim Berners-Lee

Next, you'll need to understand how websites work. This knowledge is crucial since most bug bounty programs are centered around web applications.

Online Resources:

HTML, CSS, and JavaScript (MDN Web Docs)
Web Development 101 (The Odin Project)

Recommended Book:

"Eloquent JavaScript" by Marijn Haverbeke: An excellent introduction to JavaScript and modern web development practices.

Key Concepts: Learn HTML, CSS, JavaScript, and Client-Server Model.

Practice: Create small web projects to apply your learning, such as a basic website or web app.

Step 3: Learn Programming and Scripting

"Code is poetry."

Bug bounty hunting frequently requires the creation of scripts to assess applications. Python is an excellent language for beginners in this field.

Online Resources:

CodeCademy: Learn Python3

Recommended Book:

"Automate the Boring Stuff with Python" by Al Sweigart: A practical guide to Python, perfect for beginners looking to learn scripting and automation.

Projects: Automate repetitive tasks you encounter daily, such as file management or web scraping.

Step 4: Master Cybersecurity Basics

Being aware of common vulnerabilities and their exploitation methods is crucial in the field of bug bounty hunting.

Online Resources:

Recommended Book:

"The Web Application Hacker's Handbook" by Dafydd Stuttard and Marcus Pinto: A comprehensive guide to web application security, covering various vulnerabilities and attack vectors.

Practice: Use platforms like OWASP WebGoat and DVWA (Damn Vulnerable Web Application) to practice finding and exploiting vulnerabilities.

Step 5: Dive into Ethical Hacking

Now, it’s time to get your hands dirty with some real ethical hacking.

Online Resources:

Recommended Book:

"Penetration Testing: A Hands-On Introduction to Hacking" by Georgia Weidman: A practical introduction to penetration testing, covering essential tools and techniques.

Practice: Apply techniques on vulnerable VMs from VulnHub or try exercises on Hack The Box and TryHackMe.

Step 6: Study Vulnerability Types

Learn about real-world vulnerabilities by reading and understanding case studies.

Online Resources:

Bugcrowd University

Recommended Book:

"Real-World Bug Hunting" by Peter Yaworski

Practice: Try to replicate similar findings on public bug bounty programs or in your lab environment (more on this below).

Step 7: Hands-On Practice

Put everything you’ve learned into practice by participating in Capture The Flag (CTF) competitions.

Online Resources:

Recommended Book:

"Hacking: The Art of Exploitation" by Jon Erickson: An in-depth exploration of hacking techniques with a focus on hands-on practice and understanding the underlying principles.

Practice: Regularly participate in CTFs (Capture The Flag) and practical hacking challenges.

Step 8: Develop Reporting Skills

Learning how to write clear and detailed reports is crucial for bug bounty success.

Online Resources:

HackerOne Hacktivity

Recommended Book:

"The Art of Software Security Assessment" by Mark Dowd, John McDonald, and Justin Schuh: A detailed guide on how to assess software security, including how to document and report findings effectively.

Practice: Dedicate time each day to reading reports to grasp the elements of a well-crafted report. Engage in regular practice by writing comprehensive reports on vulnerabilities discovered during your practice sessions.

Step 9: Build a Home Lab (Optional)

Establish a home lab to hone your ethical hacking skills without legal risks. You can also revisit your previous resources for further practice.

Online Resources:

Medium: Building Your Own Ethical Hacking Lab with VirtualBox: A Step-by-Step Guide

Recommended Book:

"Linux Basics for Hackers" by OccupyTheWeb: A guide to setting up and using Linux for hacking purposes, including setting up a lab environment.

Practice: Create a series of vulnerable machines to practice on.

Step 10: Stay Updated

The world of cybersecurity is always evolving. Stay informed by following industry blogs and news.

Online Resources:

Practice: Spend 15-30 minutes daily reading articles.

Step 11: Legal and Ethical Considerations

Understanding the legal and ethical aspects of hacking is crucial. You must know what you are dealing with.

Online Resources:

SANS Reading Room

Recommended Book:

"Cybersecurity Ethics" by Mary Manjikian: A comprehensive overview of the ethical and legal issues surrounding cybersecurity and hacking.

Practice: Always refer back to this knowledge when engaging in bug bounty hunting or ethical hacking activities.

Step 12: Continuous Learning and Networking

Online communities where cybersecurity professionals discuss trends and share knowledge. It connects you with like-minded individuals and professionals.

Online Resources:

r/netsec

Practice: Participate in discussions and attend webinars regularly.

Step 13: Start Hunting

Finally, put your skills to the test by joining bug bounty programs.

Platforms:

HackerOne
Bugcrowd
What are these?: Platforms where companies offer bounties for finding security vulnerabilities.
Why they're great?: They provide real-world hunting opportunities and payouts.
How to use them?: Start small, submit reports, and learn from feedback.

Conclusion

To be a successful bug bounty hunter, you must transform yourself into a person of focus, commitment, and sheer will.

Nah, you don't need to be John Wick.

All it takes is dedication and sticking to the plan. I've provided you with a rough idea of how your journey might unfold. This guide doesn't cover every detail since each step deserves its own article, but you'll learn them on your own, and that will make your learning journey more enjoyable (I sound crazy, I know).

It will be full of obstacles, as you must break free from the matrix to buy your colorful Bugatti (Spoiler Alert: Some Wholesome Angry Tourists might visit you if you don't follow the rules).

So, gear up, start learning, and happy hunting!

Remember, the journey of a thousand miles begins with a single step—or in this case, a single bug!

DEV Community: Saumyajit Purakayastha

Creating a Cluster on MongoDB Atlas

Prerequisites

Step-by-Step Guide

1. Log in to MongoDB Atlas

2. Create a New Project

3. Build a Database

4. Configure Cluster Settings

5. Create a Database User

6. Configure Network Access

7. Choose a Connection Method

8. Add a New Database to Your Cluster

9. Insert a New Document

10. Test Your Setup

Best Practices

Conclusion

REST > React? Why Blockchain Devs Should Care About the Basics

Why It Matters

Core Concepts to Master

📌 HTTP Methods Example (with curl and JavaScript)

Real-World Examples related to Web3

📌 IPFS Upload Example with Pinata (Node.js)

How This Helps in Web3 Projects

Resources

🚀 Final Thought

Footnotes:

Hey Dad, Let’s Talk About the Future of Tech!

🪙 Money Without Banks?

🤖 AI: Your Upcoming Junior Programmer?

🔐 Privacy: The Price of Convenience

💬 How Tech is Changing Us

🚀 What’s Next?

Additional Prize Categories

Context

Python Guide: Credit Card Number Validation Using Luhn's Algorithm

What is the Luhn Algorithm?

Implementing the Luhn Algorithm in Python

How It Works

Running the Program

Conclusion

Footnotes:

Bug Bounty Hunting 101: An Introduction for Beginners

Introduction

How to Start?

Step 1: Foundation in Computer Science and Networking

Online Resources:

Recommended Book:

Step 2: Understand Web Technologies

Online Resources:

Recommended Book:

Step 3: Learn Programming and Scripting

Online Resources:

Recommended Book:

Step 4: Master Cybersecurity Basics

Online Resources:

Recommended Book:

Step 5: Dive into Ethical Hacking

Online Resources:

Recommended Book:

Step 6: Study Vulnerability Types

Online Resources:

Recommended Book:

Step 7: Hands-On Practice

Online Resources:

Recommended Book:

Step 8: Develop Reporting Skills

Online Resources:

Recommended Book:

Step 9: Build a Home Lab (Optional)

Online Resources:

Recommended Book:

Step 10: Stay Updated

Online Resources:

Step 11: Legal and Ethical Considerations

Online Resources:

Recommended Book:

Step 12: Continuous Learning and Networking

Online Resources:

Step 13: Start Hunting

Platforms:

📌 HTTP Methods Example (with `curl` and JavaScript)