DEV Community: Rishabh

Future Me - Get a chance to be guided by your future self

Rishabh — Wed, 04 Mar 2026 16:25:28 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

Future Me — A Terminal That Lets You Talk to Yourself One Year From Now

What I Built with Google Gemini

Most productivity apps track what you did yesterday.

I wanted to build something that talks to who you’re becoming.

So I built Future Me — a retro-inspired terminal interface where you input your current goals, struggles, skills, and a message to yourself… and Google Gemini generates a response from “you,” one year in the future.

Not predictions.
Not generic motivation.
A structured, reflective projection of who you could become — based on who you are today.

The app asks for:

Your current goals
Your current struggles
Your skillset
A short message to your future self

Then Gemini generates:

A letter from your future self
Growth highlights you’ll achieve
Habits that will hold you back if unchanged
A practical 30-day action roadmap

I deliberately designed the UI as a retro terminal instead of a modern AI SaaS interface. It feels like you're connecting to a time machine rather than filling out a form.

The Role of Google Gemini

Google Gemini (using gemini-2.5-flash) powers the entire reflective engine.

It doesn’t just rephrase input. It:

Detects patterns in goals and struggles
Infers behavioral risks
Projects growth trajectories
Creates emotionally grounded but practical responses
Maintains structure with clearly defined output sections

The key wasn’t just “call the API.”

It was prompt engineering for introspection, realism, and specificity.

I structured the system prompt so Gemini responds as:

“Your future self, exactly one year ahead, speaking honestly but constructively.”

That framing changed everything. The output became less motivational and more grounded.

The app is deployed on Cloud Run, containerized via Docker, and scales to zero when idle.

Demo

You can try it here:

future-self-seven.vercel.app

The application is deployed on Vercel and built as a lightweight React + Tailwind SPA.

What I Learned

1. AI feels more powerful when it’s constrained

The first version of the prompt was too open-ended. The output was poetic but vague.

Once I structured the output into:

Letter
Growth Highlights
Habits to Fix
30-Day Plan

The results became dramatically more actionable.

Constraint improved creativity.

2. Tone matters more than temperature

Small changes in instruction tone had massive effects.

“Be motivating” produced generic output.

“Be honest, reflective, and slightly uncomfortable when necessary” produced depth.

Gemini responds strongly to psychological framing.

3. Retro design changes how users perceive AI

The first UI looked like every other gradient AI tool.

Switching to a monochrome terminal interface:

Removed the “startup template” feel
Increased immersion
Made the experience feel intentional

Design influences how seriously users take AI output.

4. Deploying to Cloud Run is underrated

The deployment was surprisingly simple:

Dockerized Vite build
Exposed port 8080
Deployed via gcloud run deploy --source .

Cloud Run’s scale-to-zero makes side projects economically sustainable. That alone changes how willing you are to experiment.

Google Gemini Feedback

What Worked Well

1. Structured Output Consistency

Gemini handled clearly sectioned prompts extremely well. It respected formatting boundaries and maintained narrative voice across sections.

2. Psychological Inference

Even with short inputs, Gemini identified behavioral patterns surprisingly accurately — especially around procrastination, fear of failure, and focus issues.

3. Speed

Using gemini-1.5-flash, response times were fast enough that the experience felt real-time.

Where I Felt Friction

1. Over-Optimism Bias

Without careful prompt tuning, responses defaulted to “you will succeed.” It required deliberate instruction to introduce realism and constructive critique.

2. Client-Side API Exposure

For simplicity, I called the Gemini API directly from the frontend. This exposes the API key in the client. In a production environment, I would proxy requests through a backend service.

3. Subtle Output Drift

Even with the same system prompt, tone varied slightly between sessions. It’s a reminder that prompt engineering is ongoing maintenance, not a one-time setup.

Looking Forward

Future Me started as a challenge project.

But building it changed how I think about AI tools.

The most powerful use of generative AI isn’t replacing work.

It’s accelerating reflection.

We measure performance constantly.

We rarely measure direction.

This project attempts to do that.

If Gemini continues improving in contextual reasoning and structured generation, tools like this could evolve from novelty to personal decision-support systems.

For now, it’s a time terminal.

And sometimes, that’s enough.

How I Solved the Distributed Transaction Problem in Fintech Microservices

Rishabh — Thu, 19 Feb 2026 10:07:01 +0000

The Challenge: When building financial systems with microservices, one question always comes up: How do you ensure transaction consistency across multiple services without sacrificing performance?

Traditional ACID transactions don't work well in distributed systems. Two-phase commit creates bottlenecks. So what's the solution?

The Answer: The Saga Pattern

I built a complete fintech platform to demonstrate this pattern in action. Here's what happens when a user transfers money:

Debit from source wallet
Process payment through gateway
Credit to destination wallet
Record in ledger

Each step is independent, but what if step 3 fails?

The system automatically:

Reverses the payment
Credits money back to source
Maintains complete audit trail
Ensures no money is lost or duplicated

Real-World Impact:

Zero data inconsistencies
99.9% availability maintained
Handles failures gracefully
Scales horizontally without bottlenecks

Technical Implementation:

Orchestration-based Saga coordination
Apache Kafka for event streaming
Spring Boot microservices
Complete observability with Grafana stack
Idempotent operations for reliability

This is the same pattern used by companies like Uber, Netflix, and major banks to process millions of transactions daily.

The full source code and architecture documentation are available on GitHub. Would love to hear your experiences with distributed systems!

GitHub (source code): Fintech-Microservice

What patterns have you found effective for managing distributed transactions?

What building my first SaaS (ProJamm) taught me that tutorials never did

Rishabh — Tue, 03 Feb 2026 12:47:31 +0000

I spent 6 hours debugging an issue that had nothing to do with Spring Boot, React, or my database.

The problem was… my assumptions.

That day made me realize how different building a real SaaS is from following tutorials.

Tutorials taught me:

How to create APIs
How to authenticate users
How to connect frontend and backend

But when I started building ProJamm, a real project management SaaS, I ran into problems tutorials never warned me about:

1. Deleting a project broke half the system because of hidden entity dependencies

2. One feature change forced updates across permissions, roles, tasks, and UI

3. “Simple” features like task assignment became complex once real users were involved

4. My backend worked perfectly… until edge cases appeared

Nothing was technically wrong — but the system still failed.

Here’s what I learned the hard way:

Tutorials teach syntax. Products teach responsibility.

Every decision has a blast radius
Features are connected, not isolated
“Later” technical debt arrives much sooner than expected
Users don’t care how clean your code is — they care if it works

Most importantly:

You stop coding for correctness and start coding for survivability.

Here are concrete things building ProJamm forced me to learn:

Design before code
I now sketch entity relationships before writing a single class.

Think in flows, not endpoints

“Delete project” ≠ delete one row

It means members, roles, tasks, tokens, permissions, and notifications.

Fail-safe > feature-rich
I prefer a boring feature that never breaks over a fancy one that does

Logs are more important than code elegance

log.info("Deleting project {} with {} tasks", projectId, taskCount);

This saved me more times than refactoring ever did

Build like you’ll maintain it for years
Because once users depend on it, you will

If you’re building your first SaaS and feel like:

everything is connected
changes break unrelated features
tutorials suddenly feel insufficient

You’re not doing it wrong — you’ve graduated from tutorials.

Building ProJam didn’t make me a perfect engineer.
But it taught me how real software behaves in the wild.

If you’re building something similar, I’d love to hear what surprised you the most.

Proto - You build. The world contributes.

Rishabh — Sat, 29 Nov 2025 15:11:18 +0000

A while back, I realized something:

Builders don’t lack ideas. We lack believers.

Most of us build late at night,
fix bugs no one will ever notice,
wait for feedback that never comes,
and hope someone out there understands what we’re creating.

I’ve felt that.
You probably have too.

So I asked myself — what if we didn’t build alone?

What if ideas didn’t need to fight for attention?
What if creators could earn support, love, and even rewards just for building?

That’s how Proto was born.

A community where you build,
and the world contributes back.

You earn credits, exchange them, spend them,
and grow — not alone, but with other builders like you.

No waiting list.
No gatekeeping.
Just builders helping builders.

Proto is launching soon — right in your browser.

Let’s build, together.
Your idea deserves to be seen.

hashtag#BuildInPublic hashtag#StartupJourney hashtag#Proto hashtag#CreatorsFirst hashtag#FutureBuilders

🧑🏻‍🚀My Hacktoberfest 2025 Journey: From Bug Fixes to Full-Stack Features

Rishabh — Sat, 25 Oct 2025 18:21:42 +0000

Introduction

October 2025 marked my active participation in Hacktoberfest, where I contributed to 4 open-source projects spanning Java demonstrations, full-stack web applications, and interactive games. This article chronicles my contribution journey, the technical challenges I faced, and what I learned along the way.

🎯 My Contribution Statistics

Total Merged PRs: 6+ in October 2025
Languages Used: Java, JavaScript, CSS, HTML
Project Types: Backend APIs, Frontend UIs, Game Development
Lines Changed: 1,800+ additions, 200+ deletions

Note: I have 42+ total pull requests throughout my GitHub journey. View all my contributions here.

📝 Featured Contributions

1. Admin Menu Management System - The Midnight Brew

Repository: KrishnaSaxena108/The-Midnight-Brew

PR: #56 - feat: Admin Functionality Implemented

Status: ✅ Merged | Changes: +1,867 additions, -5 deletions | Files: 9 files changed

What I Built

I implemented a complete admin panel for a cafe management system with full CRUD (Create, Read, Update, Delete) functionality for menu items and categories.

Technical Implementation

Backend (Node.js/Express):

// Created admin middleware for role-based access control
const requireAdmin = async (req, res, next) => {
    authenticateToken(req, res, async (err) => {
        if(err) return;

        const user = await User.findById(req.user.userId);

        if(user.role !== 'admin'){
            return res.status(403).json({
                success: false,
                message: 'Access denied. Admin role required'
            });
        }

        req.admin = user;
        next();
    });
};

Key Features Implemented:

Database Models:
- Created Category model with name and description fields
- Created MenuItem model with name, price, category, image, availability
- Added role field to existing User model (user/admin enum)
RESTful API Endpoints:
- GET /api/admin/menu-items - List all menu items
- POST /api/admin/menu-items - Create new menu item
- PUT /api/admin/menu-items/:id - Update menu item
- DELETE /api/admin/menu-items/:id - Delete menu item
- PATCH /api/admin/menu-items/:id/availability - Toggle availability
- Similar CRUD endpoints for categories
Frontend (Vanilla JavaScript):
- Built modal-based UI with glass-morphism design
- Real-time form validation
- Success/error notifications with animations
- Mobile-responsive design
Security Features:
- Admin-only middleware protection
- JWT token authentication
- Input validation and sanitization
- Category deletion protection (prevents deletion if menu items exist)

Challenges Overcome:

Theme Persistence: The admin panel was getting hidden during theme switches. I implemented a MutationObserver to watch for style changes and force visibility.
Dropdown Styling: Select elements needed custom styling for both light and dark themes across different browsers.

2. Java 24 Stream Gatherers Demo

Repository: AloisSeckar/demos-java

PR: #83 - feat(java24): add JEP 485 – Stream Gatherers Demo

Status: ✅ Merged | Changes: +131 additions, -1 deletion

What I Implemented

Created a comprehensive demonstration of JEP 485 (Stream Gatherers), a new Java 24 feature that enhances the Stream API with custom intermediate operations.

Technical Deep Dive

Stream Gatherers Methods Demonstrated:

fold() - Building Aggregates:

// Concatenate all numbers into a single string
Optional<String> str = numbers.stream()
    .gather(Gatherers.fold(() -> "", 
        (string, number) -> string + number))
    .findFirst();
// Result: "12345678910"

mapConcurrent() - Parallel Processing:

// Square each number using 4 concurrent threads
numbers.stream()
    .gather(Gatherers.mapConcurrent(4, n -> n * n))
    .forEach(n -> System.out.println("Square: " + n));

scan() - Running Totals:

// Show cumulative concatenation at each step
numbers.stream()
    .gather(Gatherers.scan(() -> "", 
        (string, number) -> string + number))
    .forEach(n -> System.out.println("Running total: " + n));
// Output: "1", "12", "123", "1234", ...

windowFixed() - Fixed-Size Batches:

// Group into windows of 3 elements
numbers.stream()
    .gather(Gatherers.windowFixed(3))
    .forEach(window -> System.out.println("Window: " + window));
// Output: [1,2,3], [4,5,6], [7,8,9], [10]

windowSliding() - Overlapping Windows:

// Create sliding windows of size 3
numbers.stream()
    .gather(Gatherers.windowSliding(3))
    .forEach(window -> System.out.println("Sliding Window: " + window));
// Output: [1,2,3], [2,3,4], [3,4,5], ...

What I Learned:

Stream Gatherers bridge the gap between simple stream operations and complex stateful transformations
The API provides a cleaner alternative to manual collectors
Understanding the lifecycle: initializer → integrator → finisher

3. Hibernate Search Implementation

Repository: Halverson-Jason/webStore

PR: #16 - Implemented Search functionality

Status: ✅ Merged | Changes: +95 additions, -21 deletions

The Problem

The e-commerce web store had no search functionality, making it difficult for users to find specific products.

My Solution

Implemented full-text search using Hibernate Search with Lucene backend.

Technical Implementation:

Added Dependencies (pom.xml):

<dependency>
    <groupId>org.hibernate.search</groupId>
    <artifactId>hibernate-search-mapper-orm</artifactId>
    <version>6.1.7.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate.search</groupId>
    <artifactId>hibernate-search-backend-lucene</artifactId>
    <version>6.1.7.Final</version>
</dependency>

Annotated Entity for Indexing:

@Entity
@Table(name = "products")
@Indexed  // Enable Hibernate Search indexing
public class Product {
    @FullTextField  // Make searchable
    private String name;

    @FullTextField  // Make searchable
    private String description;

    // ... other fields
}

Created Search Service:

@Service
public class SearchService {
    @PersistenceContext
    private EntityManager entityManager;

    public List<Product> searchProducts(String searchTerm) {
        SearchSession searchSession = Search.session(entityManager);

        return searchSession.search(Product.class)
            .where(f -> f.match()
                .fields("name", "description")
                .matching(searchTerm))
            .fetchHits(20);
    }
}

Created Controller Endpoint:

@Controller
public class SearchController {
    @Autowired
    private SearchService searchService;

    @GetMapping("/api/search/")
    public String search(@RequestParam("q") String q, Model model) {
        List<Product> searchResults = searchService.searchProducts(q);
        model.addAttribute("products", searchResults);
        return "home";
    }
}

Updated Frontend Forms:

<form class="form-inline" th:action="@{/api/search/}" method="get">
    <input class="form-control mr-sm-2" type="search" 
           name="q" placeholder="Search" aria-label="Search">
    <button class="btn btn-outline-success" type="submit">Search</button>
</form>

Key Learnings:

Hibernate Search provides powerful full-text search with minimal configuration
Lucene indexing happens automatically on entity changes
Multi-field searching improves result relevance

4. Game Hint System - Couple Memory

Repository: idna001/Couple-Memory

PR: #142 - feat: Implemented Hint feature

Status: ✅ Merged | Changes: +149 additions, -1 deletion

The Challenge

Players requested a hint system to help when stuck, but it needed to be balanced to maintain game difficulty.

My Implementation

Game Mechanics:

Maximum 3 hints per game
5-second cooldown between hints
Cards revealed for 2 seconds
Randomly selects two unmatched cards with matching pairs
Mobile-responsive UI

Code Highlights:

const hintCards = useCallback(() => {
    if (hintActive || hintLockedRef.current) return;
    if (hintCount === 0) return;

    // Decrement hint count
    setHintCount((c) => c - 1);
    hintLockedRef.current = true;

    // Start cooldown timer
    const seconds = Math.floor(HINT_COOLDOWN / 1000);
    setHintCooldown(seconds);

    hintIntervalRef.current = setInterval(() => {
        setHintCooldown((s) => {
            if (s <= 1) {
                clearInterval(hintIntervalRef.current);
                hintLockedRef.current = false;
                return 0;
            }
            return s - 1;
        });
    }, 1000);

    // Get available unmatched cards
    const available = cards.map((c, i) => ({ c, i }))
        .filter(({ c }) => !c.matched);

    // Select two random cards
    const idxA = crypto.getRandomValues(new Uint32Array(1))[0] % available.length;
    let idxB = crypto.getRandomValues(new Uint32Array(1))[0] % (available.length - 1);
    if (idxB >= idxA) idxB += 1;

    // Reveal cards temporarily
    setHintActive(true);
    setDisabled(true);
    setChoiceOne(available[idxA].c);
    setChoiceTwo(available[idxB].c);

    // Hide after 2 seconds
    hintTimeoutRef.current = setTimeout(() => {
        setChoiceOne(null);
        setChoiceTwo(null);
        setHintActive(false);
        setDisabled(false);
    }, REVEAL_DURATION);
}, [cards, hintCount, hintActive]);

UI Components Added:

<div className="button-box">
    <button onClick={handleNewGame}>New Game</button>
    <div className="hint-box">
        <button
            className="hint"
            onClick={hintCards}
            disabled={hintCooldown > 0 || hintCount <= 0 || hintActive}
        >
            {hintCooldown > 0 
                ? `Hint (ready in ${hintCooldown}s)` 
                : "Hint"}
        </button>
        <p className="hint-count">
            {hintCount === 1 ? "Hint Remaining: " : "Hints Remaining: "}
            {hintCount}
        </p>
    </div>
</div>

What I'm Proud Of:

Used crypto.getRandomValues() for true randomness instead of Math.random()
Proper cleanup of intervals and timeouts to prevent memory leaks
Smooth user experience with clear visual feedback

5. Mobile Responsiveness Fix - KrowdKraft

Repository: DarshanKrishna-DK/KrowdKraft

PR: #26 - feat: mobile responsiveness issue fixed

Status: ✅ Merged | Changes: +107 additions, -104 deletions

The Issue

Multiple components were breaking on mobile devices with text overflow, misaligned elements, and non-responsive layouts.

My Fixes

Implemented flexible grid layouts that collapse on smaller screens
Fixed navbar hamburger menu functionality
Adjusted font sizes with CSS clamp() for responsive typography
Optimized button sizes for touch-friendly interaction (minimum 44px)
Fixed image scaling issues with proper max-width and object-fit

Testing Approach:

Tested on Chrome, Firefox, Safari, Edge DevTools
Verified on actual mobile devices (iOS and Android)
Checked breakpoints: 320px, 375px, 425px, 768px, 1024px

6. Java JEP Documentation Links

Repository: AloisSeckar/demos-java

PR: #130 - feat(java24): Link JEP 492 demo class to JEP 482 and final JEP 513

Status: ✅ Merged | Changes: +26 additions, -43 deletions

What I Did

Updated Java Enhancement Proposal (JEP) documentation to properly link preview features to their final implementations:

JEP 447 (Java 22) → JEP 513 (Java 25) - Flexible Constructor Bodies
JEP 482 (Java 23) → JEP 513 (Java 25) - Flexible Constructor Bodies
JEP 492 (Java 24) → JEP 513 (Java 25) - Flexible Constructor Bodies

Code Changes:

/// Demo for JDK 22 feature **JEP 447 - Statements before super(...)**
///
/// Replaced with [JEP 513](https://openjdk.org/jeps/513)
/// @see org.javademos.java25.jep513.FlexibleConstructorBodiesDemo

This helps developers understand the evolution of preview features through multiple Java versions.

7. Build Fix - Foreign Function & Memory API

Repository: AloisSeckar/demos-java

PR: #80 - fix(java22): JEP 454 - ForeignFunctionMemoryDemo Build Failure

Status: ✅ Merged | Changes: +4 additions, -2 deletions

The Problem

The project wouldn't build due to:

File name and class name mismatch
Use of allocateUtf8String() method not available in JDK 22

My Solution

Implemented manual UTF-8 string allocation compatible with JDK 22's API, fixing the build and making the demo executable.

🎓 Key Takeaways

Technical Skills Gained

Full-Stack Development:
- Built complete features from database to UI
- RESTful API design and implementation
- Frontend state management without frameworks
Java Modern Features:
- Deep understanding of Stream Gatherers (JEP 485)
- Navigation through JEP preview feature evolution
- Foreign Function & Memory API nuances
Search Technology:
- Hibernate Search and Lucene integration
- Full-text indexing strategies
- Performance considerations for search
Game Development:
- React hooks for game state management
- Timer and interval management
- Random number generation best practices

Soft Skills Developed

Code Review Participation:
- Responded to reviewer feedback promptly
- Made requested changes efficiently
- Learned from maintainer suggestions
Documentation:
- Wrote clear PR descriptions with screenshots
- Added meaningful code comments
- Created comprehensive demo examples
Testing:
- Cross-browser testing methodology
- Mobile-first responsive design approach
- Manual QA before submission

📈 Impact

My contributions have:

✅ Added admin capabilities to a production cafe management system
✅ Provided educational Java 24 examples for the developer community
✅ Enabled product search for an e-commerce platform
✅ Improved user experience with hint system in a memory game
✅ Made applications accessible on mobile devices
✅ Fixed build failures blocking other contributors
✅ Improved documentation for Java version migration

🚀 What's Next?

Continue Contributing: I plan to maintain these projects and add more features
Become a Maintainer: Working towards maintainer status on projects I'm passionate about
Start My Own OSS: Planning to create an open-source library for common Java patterns
Mentor Others: Help newcomers with their first Hacktoberfest contributions

💭 Final Thoughts

Hacktoberfest 2025 was more than just making PRs—it was about:

🤝 Connecting with maintainers and learning from their expertise
📚 Understanding real-world codebases and their challenges
🔧 Solving actual problems that users face
🌱 Growing as a developer through diverse technical challenges

Every contribution, whether a bug fix or a new feature, made me a better developer. The open-source community's welcoming nature and constructive feedback were invaluable.

To fellow contributors: Don't hesitate to start. Pick a project you use, find an issue, and give it a shot. The community is here to help!

🔗 Connect With Me

GitHub: @rishabhrawat05
Portfolio: https://rishabh-singh-rawat.vercel.app/

ProJam UI is Ready

Rishabh — Tue, 06 May 2025 14:41:20 +0000

I’ve been constantly working on the design of my ProJam app for the past month, and it’s finally complete!
I designed it in Figma, and through this project, I learned Figma by practicing. Since it’s for my startup, I wanted to add prototyping as well.

What is prototyping, you ask? Don’t worry, I’ll tell you.
Prototyping in Figma allows you to make buttons functional—like when you click a button, it defines what should happen next or where it should navigate.

The biggest challenge I faced during the design process was finding the right color palette and font. Initially, my colour choices weren’t great, and the design didn’t look appealing. Then my sister stepped in and helped me find a suitable colour palette. After trying a few previews, I finally found one that worked well.
As for the font, I went with Figma’s default Krona One, which looks modern and pairs well with the colour palette.

Now, the tricky part was juggling my studies and design work. My exams were going on, and somehow, whenever exams arrive, my passion shifts from studying to crazy ideas like this. But despite that, I managed to complete the entire design, including features like dashboard, projects, workspaces, and more.

Tired of messy projects and scattered tasks?

Rishabh — Mon, 05 May 2025 11:45:50 +0000

𝐀𝐫𝐞 𝐲𝐨𝐮 𝐚 𝐬𝐭𝐮𝐝𝐞𝐧𝐭, 𝐟𝐫𝐞𝐞𝐥𝐚𝐧𝐜𝐞𝐫, 𝐨𝐫 𝐛𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐟𝐨𝐫 𝐚 𝐡𝐚𝐜𝐤𝐚𝐭𝐡𝐨𝐧?
And haven't joined the 𝐏𝐫𝐨𝐉𝐚𝐦 waitlist, you are missing out on something big!!!!

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐏𝐫𝐨𝐣𝐚𝐦?
ProJam is an app that helps you manage your workspace, projects, and tasks, and also provides detailed analytics with a simple and intuitive UI experience.

𝐖𝐡𝐲 𝐚𝐦 𝐈 𝐫𝐞𝐪𝐮𝐞𝐬𝐭𝐢𝐧𝐠 𝐲𝐨𝐮 𝐭𝐨 𝐣𝐨𝐢𝐧 𝐏𝐫𝐨𝐣𝐚𝐦?
1) Fall in love with the smooth and minimal UI
2) Simplify how you manage tasks, projects, and workspaces
3) Gain valuable analytics and insights into your project’s performance
4) Easily manage team members across projects

𝐉𝐨𝐢𝐧 𝐭𝐡𝐞 𝐰𝐚𝐢𝐭𝐥𝐢𝐬𝐭 𝐧𝐨𝐰 𝐭𝐨 𝐠𝐞𝐭 𝐞𝐚𝐫𝐥𝐲 𝐚𝐜𝐜𝐞𝐬𝐬 𝐟𝐨𝐫 𝐟𝐫𝐞𝐞: https://projam.vercel.app/

Also, 𝐭𝐡𝐚𝐧𝐤 𝐲𝐨𝐮 if you’ve already signed up! I’ll make sure your projects are easily managed and your experience with ProJam is as seamless as possible.

Chasing the Map Dream: My Journey of Building a Navigation System

Rishabh — Fri, 14 Mar 2025 15:21:36 +0000

A few months ago, I had the crazy idea of building an app like Google Maps for route suggestions. Many people thought it was pointless—after all, why reinvent something so polished? But as a developer, the urge to build it myself was irresistible.

I knew that using the Google Maps API would cost money, so I went hunting for free third-party APIs. After days of research and asking ChatGPT, I still couldn’t find one that fit the bill. Some were way too confusing, while others just didn’t offer the data I needed.

One evening, determined to crack the code, I stumbled upon an API that could provide route data—but only if I had latitude and longitude. No problem—I found another API to fetch those coordinates. I was finally getting somewhere! However, it still lacked estimated time calculations, especially with traffic in mind.

To fill the gap, I integrated yet another API that calculated traffic within segments. Combining everything, I had to traverse the coordinates from start to end and calculate the distance using the Haversine formula. The response time shot up to 30 seconds—definitely not practical for a navigation app.

I knew I needed to speed things up, so I dove into multithreading to optimize the response time. After plenty of debugging and trial and error, I managed to reduce it to about 10 seconds. Not perfect, but way better than before.

When the final API response came through and closely matched Google Maps, I was honestly blown away. It was like watching my idea come to life after countless hurdles. This project pushed me to research, debug, and learn more about multithreading—an unforgettable journey that made me a better developer.

It wasn’t about competing with Google Maps. It was about pushing myself to build something challenging and seeing it through. That’s the kind of satisfaction that keeps me coding.