DEV Community: Maha Darshini

The Password Reset That Worked Until It Had to Send an Email

Maha Darshini — Thu, 20 Aug 2026 10:32:28 +0000

The plan was straightforward:

Frontend
   ↓
Backend API
   ↓
PostgreSQL

Signup, login, JWT, refresh tokens, forgot password, reset password.

But getting all of it working exposed a chain of bugs that taught us much more about debugging than simply implementing the feature.

The First Crash: Duplicate Spring Beans

The backend wouldn't even start.

The first error was:

ConflictingBeanDefinitionException:
Annotation-specified bean name 'AIResponseParser'
conflicts with existing bean definition

There were two different classes with the same name:

com.investmentai.ai.util.AIResponseParser
com.investmentai.ai.parser.AIResponseParser

Both were registered as Spring components.

Instead of randomly deleting one, we searched the project for every reference:

Get-ChildItem src\main\java -Recurse -File -Filter *.java |
Select-String -Pattern "AIResponseParser"

That helped us identify which implementation was actually being used.

After resolving the duplicate, we tried again.

And got another duplicate bean.

Round Two: Another Duplicate Bean

This time:

ConflictingBeanDefinitionException:
Annotation-specified bean name 'tokenValidator'

There were two classes:

ai.security.TokenValidator
ai.validator.TokenValidator

They had completely different responsibilities, but Spring derived the same default bean name from both classes.

Again, we searched for usages before changing anything.

The lesson was simple:

Don't fix a startup error blindly. First understand why both components exist and where they're being used.

After resolving this conflict, the backend finally started.

🗄️ Next Problem: Database Configuration

The authentication system depended on PostgreSQL running through Docker.

We verified the container:

docker compose ps

Then verified the database directly:

docker compose exec postgres psql -U myuser -d mydatabase

And checked the tables:

flyway_schema_history
refresh_tokens
users

This helped separate the problem into two independent parts:

Application configuration
        ↓
Database connectivity
        ↓
Database schema

Instead of assuming the database was broken, we tested it independently.

That made debugging much easier.

🔐 Finally: Signup and Login

Once the backend was stable, we tested signup directly through the API.

POST /auth/signup

The user was successfully created.

Then:

POST /auth/login

returned a JWT access token.

We also verified that the user was actually stored in PostgreSQL.

At this point, the core authentication flow was working:

Signup
   ↓
PostgreSQL
   ↓
Login
   ↓
JWT

But authentication still had one major feature left.

Forgot password.

🔑 Building the Password Reset Flow

We created a dedicated password reset token table.

The important part of the design was that we didn't store the raw reset token in the database.

The flow was:

User requests password reset
          ↓
Generate random token
          ↓
Hash token
          ↓
Store hash in PostgreSQL
          ↓
Send raw token through email
          ↓
User clicks reset link
          ↓
Validate token
          ↓
Update password

We also tracked:

expiration
whether the token was already used
the associated user

The database migration was applied successfully.

The reset link was generated correctly.

The reset page opened correctly.

Everything looked good.

Except...

the email never arrived.

📧 The SMTP Problem

We initially used Gmail SMTP.

The configuration looked normal:

spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

But the backend returned:

535-5.7.8 Username and Password not accepted

This was interesting because the application could successfully connect to Gmail's SMTP server.

The failure was happening specifically during authentication.

We checked the environment variables.

We checked the App Password.

We checked the SMTP configuration.

We eventually realised that relying on a local .env file did not automatically make those variables available to the Spring Boot process.

That was another useful lesson:

A configuration file existing in your project doesn't necessarily mean your application is actually receiving those values.

🔄 Changing the Approach

We replaced:

Spring Boot
    ↓
Gmail SMTP
    ↓
Authentication failure

with:

Spring Boot
    ↓
Email API
    ↓
User's inbox

The important part was that we didn't rewrite the password-reset logic.

The existing service still did:

emailService.sendPasswordResetEmail(
    user.getEmail(),
    resetUrl
);

Only the implementation of EmailService changed.

This was a good example of why separating business logic from infrastructure matters.

The authentication service shouldn't care whether an email is delivered through SMTP or an API.

🎯 The Final Test

We triggered:

POST /auth/forgot-password

The backend:

Found the user.
Generated a reset token.
Stored the token hash.
Created the reset URL.
Sent the email through the new email service.

And finally:

📩 The reset email arrived.

The user clicked the link.

The reset page opened.

The password was changed.

The new password worked for login.

🧠 What This Bug Taught Me

The biggest lesson wasn't about Spring Boot, PostgreSQL or email APIs.

It was about debugging by layers.

Instead of looking at the entire authentication system as one big problem, we broke it down:

Frontend
   ↓
HTTP Request
   ↓
Spring Controller
   ↓
Authentication Service
   ↓
JWT / Token Logic
   ↓
PostgreSQL
   ↓
Email Service
   ↓
Email Provider

Then we tested each layer independently.

A problem that initially felt like:

"Authentication isn't working."

became several smaller, solvable problems:

Duplicate Spring beans
Database verification
Migration verification
Environment variable configuration
SMTP authentication
Email provider integration

And that made the debugging process much less overwhelming.

🏁 From Broken to Working

The final authentication flow became:

              Authentication
                     │
        ┌────────────┼────────────┐
        ↓            ↓            ↓
     Signup        Login      Forgot Password
        │            │            │
        ↓            ↓            ↓
   PostgreSQL      JWT       Reset Token
                                  │
                                  ↓
                              Email API
                                  │
                                  ↓
                             Reset Link
                                  │
                                  ↓
                           New Password
                                  │
                                  ↓
                                Login

The best part wasn't that we avoided bugs.

We didn't.

The best part was learning how to trace a failure, isolate the layer causing it, verify assumptions, and change only what actually needed changing.

Sometimes debugging isn't about finding one bug.

Sometimes it's about following the trail until the whole system finally makes sense.

Ever wondered how a computer knows that two sentences mean almost the same thing? 🤔

Maha Darshini — Mon, 17 Aug 2026 15:00:46 +0000

“I'm feeling sleepy.”
“I'm really tired.”

Different words. Similar meaning.

That’s where Similarity Search comes in. Text can be converted into embeddings (vectors), and similar meanings are represented closer together in vector space.

So instead of searching only for the exact same words, we can find results with a similar meaning.

This is used in search engines, chatbots, recommendation systems, document search, RAG, and much more.

Day 1 of learning something I’m curious about. 🔍

Mysore-pak

Maha Darshini — Thu, 13 Aug 2026 18:04:06 +0000

Inspiration

For this challenge, I chose Mysore Pak, a traditional South Indian sweet and one of my favourite comfort foods.

I wanted to recreate something that feels familiar and nostalgic using CSS as the main creative medium. The golden colour, ghee-rich texture, soft edges, and layered pieces of Mysore Pak gave me a lot of small details to experiment with.

Demo

[https://splendorous-heliotrope-dc872c.netlify.app/]

Journey

I started by breaking Mysore Pak down into simple visual elements — rectangular sweet pieces, golden gradients, ghee highlights, crumbs, shadows, and a serving plate.

Instead of using an image, I created the artwork primarily with CSS gradients, pseudo-elements, shadows, transforms, and animations.

I also added subtle animations to make the artwork feel alive:

✨ Floating and rotating sparkles
🧈 Ghee highlights and shimmer effects
🍯 Gentle movement of the Mysore Pak pieces
🍽️ Plate light reflection
💫 Small floating crumbs
🌟 Smooth entrance animations

One of the things I'm most proud of is turning a simple sweet into a detailed CSS illustration without depending on an image asset.

This challenge also reminded me that frontend development can be a creative medium, not just a way to build interfaces.

Made with ❤️, CSS, ghee, gram flour, sugar, and a little South Indian nostalgia.

Biryani Tales - A Deliciously Illustrated History

Maha Darshini — Thu, 13 Aug 2026 17:56:25 +0000

What I Built

Biryani Tales — A Deliciously Illustrated History

For this challenge, I chose one of my favourite comfort foods: biryani.

I built an interactive landing page that takes visitors on a visual journey through the history, regional varieties, and cultural stories behind biryani.

The page includes:

🍚 An illustrated hero section featuring a realistic biryani handi
📜 An interactive timeline exploring the history of biryani
🌶️ Regional biryani varieties from across India
🗺️ A "Biryani Flavour Atlas" highlighting regional styles
🃏 Flip cards containing interesting biryani trivia
🎡 An interactive "Spin the Pot" wheel that randomly picks a biryani
✨ Scroll animations and interactive UI elements
📱 Responsive design for different screen sizes

I wanted the page to feel warm, playful, and food-focused rather than like a traditional informational website.

Demo

[https://delicate-sunburst-b67e2e.netlify.app/]

Repo Link:
[https://github.com/Mahadarshini/briyani]

Journey

The main idea was to turn something as familiar as biryani into a small interactive storytelling experience.

I started with the visual direction first — warm cream, saffron, chilli, and masala-inspired colours — and then built the different sections around the story of biryani.

One of the parts I enjoyed most was creating the biryani handi using CSS, rather than simply using a static image. I experimented with gradients, shadows, layering, rice grains, herbs, meat pieces, metallic textures, steam, and animation to make the pot feel more like a real restaurant-style handi.

I also wanted the page to have small interactions that make people want to explore, so I added the flip-card trivia section and the interactive biryani wheel.

What I learned

This challenge helped me think beyond simply making a page "look good." I focused more on:

Creating a visual hierarchy
Making interactions feel purposeful
Using CSS to create illustrated elements
Building a consistent visual language
Making a storytelling experience through frontend design

I'm particularly proud of how the biryani pot evolved from a simple CSS illustration into a more detailed restaurant-style handi.

What's next?

I'd like to take this further by adding:

More regional biryani stories
Real photographs and recipes
Sound effects and subtle food animations
A recipe section
Better mobile interactions
More interactive storytelling elements

Built with ❤️, CSS, JavaScript, and a lot of biryani cravings.