DEV Community: Tejasvi Urkande

🚀 Building a Full Stack Employee Management System with Spring Boot, React, and MySQL

Tejasvi Urkande — Thu, 13 Nov 2025 11:29:02 +0000

Hey everyone!

I’m excited to share my recent project — a Full Stack Employee Management System built using Spring Boot (Backend), React (Frontend), and MySQL (Database).
This project helped me understand how frontend and backend communicate seamlessly through REST APIs and how CRUD operations work end-to-end.

🧩 Tech Stack

Frontend: React, Bootstrap, Axios, React-Router
Backend: Spring Boot, Java
Database: MySQL
Tools: Postman, VS Code, IntelliJ IDEA

💡 Project Overview

The Employee Management System (EMS) is a simple yet powerful CRUD application that allows users to:

➕ Add a new employee
📋 View all employees
✏️ Update employee details
❌ Delete an employee

The frontend is built with React, fetching and updating data via REST APIs created in Spring Boot. All employee records are stored in MySQL.

⚙️ Backend (Spring Boot)

I created REST APIs using Spring Boot:

GET /api/employees → Fetch all employees
POST /api/employees → Add a new employee
GET /api/employees/{id} → Get employee by ID
PUT /api/employees/{id} → Update employee
DELETE /api/employees/{id} → Delete employee

I also integrated CORS to allow communication with the React frontend.

💻 Frontend (React)

For the frontend, I used React Hooks (useState, useEffect) and React Router for navigation.
The UI has:

A list page displaying all employees in a table

An “Add Employee” form
An “Update Employee” form
A header and footer for a clean layout
API calls are made using Axios, and the state updates dynamically without page reloads.

🗄️ Database (MySQL)

I designed a simple table structure:

CREATE TABLE employees (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
first_name VARCHAR(50),
last_name VARCHAR(50),
email VARCHAR(100)
);

The application connects to MySQL through the application.properties file in Spring Boot.

🔗 Integration Flow

React sends requests to the backend API (Axios).
Spring Boot handles requests, performs CRUD operations via JPA.
MySQL stores and retrieves employee data.
React updates UI dynamically based on responses.

🎯 What I Learned

Connecting React frontend with a Spring Boot backend
Managing REST API calls using Axios
Handling form data and routing with React Router
Writing CRUD operations using Spring Data JPA
Understanding full-stack workflow and debugging cross-origin issues (CORS)

This project was a great hands-on experience to strengthen my Java + React full-stack skills.
It gave me a clearer picture of how data flows between frontend, backend, and database layers.

If you’re learning full stack development, I highly recommend building a CRUD app like this — it’s the perfect foundation for larger enterprise applications.

🔗 GitHub Repository

👉 View the Source Code: https://github.com/tejasviurka/ems-fullstack

🚀 Week 3 – Spring Data JPA & CRUD Operations in Spring Boot

Tejasvi Urkande — Fri, 10 Oct 2025 16:57:28 +0000

This week, I moved one step ahead from just building REST APIs to connecting them with a real database using Spring Data JPA and H2 Database.
This helped me understand how data actually flows between the backend and the database — and how Spring simplifies everything for us.

🔹 Why Spring Data JPA?

Before using JPA, I tried understanding the evolution:

JDBC → Too much code: connection, statements, result sets, closing resources.
Spring JDBC → Reduced boilerplate but still SQL-heavy.
ORM (Object Relational Mapping) → Maps Java classes to database tables, making data handling object-oriented.
JPA (Java Persistence API) → A standard for ORM so we can switch tools like Hibernate easily.
Spring Data JPA → Builds on top of JPA and gives ready-made repository methods like save(), findAll(), deleteById() etc.

💡 In short:
Spring Data JPA lets you work with objects instead of SQL queries, saving time and effort.

🔹 Setting Up Spring Data JPA + H2

Added dependencies in pom.xml for:
spring-boot-starter-data-jpa

h2

Configured my H2 in-memory database in application.properties:

spring.datasource.url=jdbc:h2:mem:tejasvi
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=update
spring.h2.console.enabled=true
spring.jpa.show-sql=true

💡 Tip:
jdbc:h2:mem:tejasvi creates an in-memory DB (wiped when app stops).
To persist data even after restart, use jdbc:h2:~/tejasvi.

🔹 Building Repository Layer

Created an interface for database operations:

public interface ProductRepo extends JpaRepository {}

No need to write SQL queries anymore — this gives me all CRUD methods automatically.

💡 Bonus:
If I want a custom finder, I can just define:
List findByName(String name);
Spring automatically generates the query!

🔹 Controller + Service Layer

Controller to handle HTTP requests:

@RestController
@RequestMapping("/products")
public class ProductController {
@Autowired
private ProductService service;

@GetMapping("/{id}")
public Product getProduct(@PathVariable int id) {
    return service.getProductById(id);
}

@PostMapping
public void addProduct(@RequestBody Product product) {
    service.addProduct(product);
}

@PutMapping
public void updateProduct(@RequestBody Product product) {
    service.updateProduct(product);
}

@DeleteMapping("/{id}")
public void deleteProduct(@PathVariable int id) {
    service.deleteProduct(id);
}

}

💡 Used annotations:

@RestController → Combines @Controller + @ResponseBody
@RequestBody → To map JSON input from Postman to Java objects
@PathVariable → To read parameters from URL

🔹 Common Problems & How I Fixed Them

Problem 1: Table not found (or “no such table”)

Cause:
I forgot to annotate my model class with @Entity.
Without @Entity, JPA doesn’t recognize it as a table to create in H2.

Solution:
Add these annotations to your class:

@Entity
@Table(name = "products")
public class Product {
@id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
private double price;
}

Also make sure spring.jpa.hibernate.ddl-auto=update is set, so Hibernate creates or updates tables automatically.

Problem 2: “Failed to convert value of type 'java.lang.String' to required type 'int'”

Cause:
Sent wrong data format in Postman. For example, ID was sent as a string ("id": "1") instead of a number.

Solution:
Always match data types correctly while sending JSON.
Example valid body:

{
"name": "Laptop",
"price": 55000
}

Problem 3: H2 console not opening

Cause:
Didn’t enable console in properties file.

Solution:
Add:

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

Then open: http://localhost:8080/h2-console

and make sure JDBC URL matches what’s in your properties file.

Problem 4: Data not visible in H2 after POST request

Cause:
Used an in-memory database (mem:). Once the app restarts, all data is gone.

Solution:
Use persistent database for local testing:

spring.datasource.url=jdbc:h2:~/tejasvi
This creates a file-based DB stored in your system.

Problem 5: “Detached entity passed to persist” or duplicate insert errors

Cause:
When calling save() for existing entities, JPA tries to insert instead of update.

Solution:
Always include the correct ID for updates:

product.setId(existingId);
repository.save(product);

Or check first using findById() before updating.

Problem 6: @Autowired NullPointerException

Cause:
Created service/repo object manually using new keyword instead of letting Spring inject it.

Solution:
Never use new for beans. Always annotate:

@Service
public class ProductService { ... }

@Autowired
private ProductService service;

Let Spring handle object creation and dependency injection.

✅ Week 3 Takeaways

✔ Understood the evolution from JDBC → JPA → Spring Data JPA
✔ Configured and used H2 Database successfully
✔ Built CRUD APIs using JpaRepository
✔ Tested all endpoints using Postman
✔ Learned to fix real-time errors like missing @Entity, wrong JSON types, and dependency issues
✔ Understood how Spring auto-generates queries and handles transactions

💡 Why I’m Sharing

Learning backend development is not just about writing code — it’s about understanding why errors happen and how to fix them smartly.
By documenting my weekly learnings, I can reflect on my mistakes and also help other beginners avoid the same pitfalls while learning Spring Boot.

SpringBoot #JPA #H2Database #CRUD #BackendDevelopment #JavaDeveloper #100DaysOfCode

Want to Understand Bitcoin, Blockchain & Web3? Read This Once and Get It!

Tejasvi Urkande — Sun, 05 Oct 2025 06:30:51 +0000

Understanding Bitcoin: A Simple Walkthrough of Satoshi’s Whitepaper

Cryptocurrencies, led by Bitcoin, have revolutionized how we think about money. At the heart of it lies a brilliantly simple yet powerful concept — a decentralized electronic cash system that works without banks or trusted intermediaries. Satoshi Nakamoto’s whitepaper, written in 2008, laid the foundation for this system. Here’s a breakdown in easy-to-digest terms, perfect for developers and tech enthusiasts.

1. The Problem: Trust and Double-Spending

Traditionally, online payments rely on trusted third parties (banks or payment processors). This introduces a few challenges:

Transaction mediation: Banks must resolve disputes.
High costs: Mediation increases transaction fees and prevents small payments.
Trust issues: Merchants and users must trust the central authority. Bitcoin solves this by using cryptographic proof instead of trust, allowing two parties to transact directly.

2. Transactions: Digital Signatures & Ownership

Bitcoin transactions are like digital cash transfers, controlled by digital signatures.
Each coin is a chain of signatures, tracing its ownership.
The main challenge is preventing double-spending.
Instead of a central “mint,” transactions are publicly announced and verified by the network consensus.

3. Timestamp Server: Recording History

To prevent cheating, Bitcoin uses a distributed timestamp server:
Each block contains a hash of previous blocks and new transactions.
This creates a chain of timestamps, making the history tamper-proof.

4. Proof-of-Work: Making Cheating Hard

Adding a block isn’t free — it requires solving a computational puzzle:
Miners find a nonce so the block’s hash starts with zeros.
Changing any past block would require redoing the Proof-of-Work for that block and all following blocks.
This ensures the blockchain is secure and immutable.

5. Network: How Nodes Agree

Bitcoin nodes work together to maintain the blockchain:
Broadcast new transactions.
Collect them into blocks.
Solve Proof-of-Work to add a block.
Broadcast the block.
Verify validity.
Nodes always trust the longest chain (most cumulative work).
Even if two blocks appear at the same time, the network naturally resolves conflicts.

6. Incentive: Why Miners Play Fair

Miners are motivated by rewards:
Block reward: New coins created in each block.
Transaction fees: Difference between transaction inputs and outputs.
Even if a miner controls a majority of computing power, it’s more profitable to follow the rules than to cheat.

7. Reclaiming Disk Space

Blockchain data grows over time. Bitcoin solves this with Merkle Trees:
Transactions are hashed in a tree structure.
Only the Merkle root is stored in the block header.
Old transaction data can be pruned while keeping the blockchain valid.
Block headers alone take ~4.2 MB per year, making storage manageable.

8. Simplified Payment Verification (SPV)

Not everyone needs the full blockchain:
SPV wallets download only block headers.
They use Merkle branches to verify transactions.
Faster and lighter, but slightly less secure than running a full node.

9. Combining and Splitting Value

Bitcoin handles value flexibly:
Transactions can have multiple inputs and outputs.
Example: Combine smaller coins to make a payment and return change to the sender.
Even if transactions depend on many previous transactions (fan-out), it’s not a problem for verification.

10. Privacy

Bitcoin provides pseudonymity:
Public can see transactions, but not who owns the keys.
Using new key pairs for each transaction strengthens privacy.
Multi-input transactions may reveal some links, but careful key management mitigates this.

12. Conclusion: Trustless, Decentralized Money

Bitcoin combines digital signatures, Proof-of-Work, and peer-to-peer networking to create a trustless electronic cash system:
Nodes vote with CPU power.
The longest chain represents consensus.
Miners are incentivized to be honest.
The network is robust, decentralized, and self-regulating.

💡 Final Thoughts:

Bitcoin is not just digital money — it’s a revolution in trust. By combining cryptography, game theory, and decentralized networking, it enables secure transactions without banks, without central authorities, and without intermediaries.

📅 Week 2 – Spring Boot Web & REST API Fundamentals

Tejasvi Urkande — Sun, 21 Sep 2025 18:01:16 +0000

This week, I continued my journey into Spring Boot and focused on building REST APIs, understanding dependency injection in depth, and testing APIs with Postman.

🔹 Dependency Injection & @Autowired

Explored dependency injection (DI) further.
Constructor injection → Clean, works without @Autowired.
Field injection → Needs @Autowired to inject object references.

@Autowired tells Spring to find the right bean by type and inject it automatically, making the code loosely coupled and easier to test.

💡 Mistake I made:
Initially tried manually creating objects like in core Java. This broke IoC. Learned to always let Spring manage object creation.

Also explored Spring XML Config to define beans manually. While annotations make life easier now, knowing XML configuration is useful for fundamentals and interviews.

🔹 Spring Boot Web & REST APIs

Learned to create REST APIs using @RestController & @RequestMapping.

Discovered that @RestController combines @Controller + @ResponseBody, so we don’t need to manually add @ResponseBody.

Used @RequestMapping to map endpoints like /api/hello and handle requests.

💡 Problem I faced:
Using @Controller without @ResponseBody caused the API to return a view error. Switching to @RestController fixed it.

Learned the DispatcherServlet flow: Spring receives HTTP requests, routes them to the correct controller, and returns a response.

🔹 HTTP Methods & Postman Practice

Learned HTTP methods for REST APIs:
• GET → Retrieve data from the server.
• POST → Send data to the server to create new resources.

Practiced sending requests and receiving responses using Postman.
Learned to use @RequestBody for POST requests to handle JSON input.

💡 Mistake I made:
Forgot @RequestBody initially → POST data wasn’t received properly. Postman helped me debug quickly.

✅ Week 2 Takeaways

Understood dependency injection in detail (@Autowired, constructor vs field injection).
Explored Spring XML configuration to understand legacy bean management.
Built REST APIs efficiently using @RestController & @RequestMapping.
Learned HTTP methods (GET, POST) and tested APIs with Postman.
Understood the DispatcherServlet request flow.
Identified common mistakes and learned how to fix them.

💡 Why I’m Sharing:
Documenting my weekly progress helps me retain knowledge and also helps other beginners avoid common pitfalls while learning Spring Boot.

Java #SpringBoot #RESTAPI #DependencyInjection #FullStackDevelopment #BackendDevelopment #100DaysOfCode

📅 Week 1: Diving into Spring Boot Fundamentals:

Tejasvi Urkande — Sat, 06 Sep 2025 13:31:15 +0000

Hey everyone! 👋

This week marks the first milestone in my 5-month Java Full Stack learning journey. I focused on Spring Boot fundamentals and got hands-on with core concepts that every backend developer must know.

Here’s what I explored, practiced, and learned (including a few beginner mistakes I ran into).

🔹 Spring Boot Modules & Layers

Spring Boot is modular, and understanding its architecture made everything much clearer:

Web Module → Helps in building web applications (Controllers, REST APIs).
Data Module → Handles database operations (JPA, repositories).
AOP Module → Aspect Oriented Programming (adding cross-cutting concerns like logging, security, transactions without touching core logic).
Core Module → Manages dependencies and the IoC container.
Test Module → Provides testing support for Spring components.

Beginner Tip: At first, I thought Spring Boot was just for APIs, but these modules show how it handles everything — from requests to DB to testing.

🔹Dependency Management & IoC:

Instead of manually handling dependencies, Spring Boot uses IoC (Inversion of Control).

IoC Principle: Object creation & dependency management is shifted from developer to the Spring container.

Dependency Injection (DI): The actual implementation of IoC.

Two ways I tried dependency injection:

Constructor Injection → Cleaner, recommended, no need for @Autowired.
Field Injection → Needs @Autowired annotation.

@Service
public class UserService {
private final UserRepository userRepository;

// Constructor injection (preferred)
public UserService(UserRepository userRepository) {
    this.userRepository = userRepository;
}

}

Beginner Mistake I made: At first, I kept adding new to create objects like we do in core Java. That broke the whole point of IoC! Instead, you should always let Spring handle object creation via DI.

🔹 Working with Beans

In Spring, Beans = Java Objects that the IoC container manages.
Instead of creating objects manually, you define them and let Spring inject them wherever needed.
This makes code loosely coupled and easier to test.

🔹Autowiring

I also learned about @Autowired in Spring Boot.
It tells Spring: “Find the right bean by type and inject it here.”
Super useful when connecting two classes (e.g., Controller → Service).

🔹 Spring XML Config

Before Spring Boot, you had to configure beans in XML files.
Example:

Thankfully, Spring Boot made life easier with annotations + auto-configuration. But it’s good to know the old way for interviews & fundamentals.

🔹 Servlet Dispatcher & REST APIs

I dug into the DispatcherServlet, the front controller in Spring.
It receives HTTP requests.
Delegates them to the correct controller.
Returns the response.

I also practiced building REST APIs using annotations like:

@RestController → Defines API endpoints.

@data, @AllArgsConstructor → From Lombok, helps reduce boilerplate.

🔹 Database Connection (Persistence Layer)

I connected Spring Boot with a database using JPA. Steps:
Added DB dependencies (e.g., MySQL).
Updated application.properties with DB credentials.
Used JPA repository for CRUD operations.

Example:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=pass
spring.jpa.hibernate.ddl-auto=update

Beginner Mistake I made: Forgot to add the correct driver dependency → application failed to start. Always double-check your pom.xml / build.gradle.

✅ Week 1 Takeaways

Understood Spring Boot’s layered modules (Web, Data, AOP, Core, Test).
Explored IoC, DI, Beans, and Autowiring.
Learned constructor vs field injection.
Understood the DispatcherServlet flow.
Built REST APIs with annotations.
Connected Spring Boot with DB using JPA.
Learned about XML config (old but gold).

💡 Why I’m Sharing This

I’m documenting everything I learn publicly — the wins, the struggles, and the mistakes — so that beginners can learn faster and avoid my mistakes.

👉 Full code examples will be uploaded on my GitHub soon.
👉 Daily updates are on Twitter.

If you’re also learning Java Full Stack, let’s connect and grow together 🚀

Java #SpringBoot #FullStackDevelopment #LearnInPublic #100DaysOfCode

Starting My AI Learning Journey From Scratch 🚀

Tejasvi Urkande — Tue, 05 Aug 2025 09:20:54 +0000

Hey dev community! 👋

I've been seeing AI everywhere lately, and honestly, I got curious. What's all this hype actually about? Instead of just wondering, I decided to dive in and learn this thing from scratch. So here I am, documenting my journey as I explore the world of AI!

Why I'm Learning AI

Pure curiosity. The AI wave is impossible to ignore, and I wanted to understand what's really happening behind all the buzz.
I'm approaching this with a beginner's mindset - no assumptions, just genuine exploration and hands-on learning.

My Learning Resources

I'm following the FreeCodeCamp course with instructors Andrew Brown and Rola Dali, plus exploring on my own using various AI models. The combination of structured learning and practical experimentation feels like the right approach.

Day 1: Understanding the AI Landscape

🌊 The AI Wave - What's Actually Happening?

Today I learned that we're not just in an "AI boom" - we're in a complete paradigm shift. The accessibility of AI tools has capabilities that were previously available only to tech giants. Anyone can now access powerful AI capabilities through simple interfaces.

🛠️ Types of AI Tools (My First Exploration)

Conversational AI:

ChatGPT, Claude, Gemini
General problem-solving, explanations, creative tasks

Code Assistance:

GitHub Copilot, Cursor, Replit AI
Code generation, debugging, refactoring

Creative Tools:

Image generation (DALL-E, Midjourney)
Audio processing (ElevenLabs)
Video creation (RunwayML)

🔄 How AI Changes Everything

The biggest realization: AI isn't just another tool - it's a new way of working. Instead of searching for solutions or spending time on repetitive tasks, we can have intelligent conversations with AI to solve problems, generate ideas, and automate workflows.

⚙️ Setting Up My AI Learning Toolkit

I've started experimenting with several tools:

ChatGPT - for learning and problem-solving
Claude - for detailed technical explanations
GitHub Copilot - testing AI-assisted coding
Cursor - AI-powered code editor
Midjourney - exploring AI image generation

📚 Understanding AI Evolution (The Quick Version)

The journey from basic computing to today's generative AI is fascinating:

Perceptrons → Neural Networks → Deep Learning → Transformers → LLMs → Generative AI

Each breakthrough solved the limitations of the previous approach, leading to today's AI capabilities that can understand context, generate creative content, and assist in complex reasoning tasks.

What's Next?

Starting Day 2, I'm diving into ML fundamentals. I want to understand:

My Learning Commitment

I'll be posting weekly updates on:

Dev.to - detailed learning summaries and insights
Twitter - quick updates and interesting discoveries

This helps me stay accountable while sharing knowledge with the community. Plus, documenting the journey helps me learn better!

Why This Exploration Matters

We're living through a technological shift that happens maybe once in a generation. Whether AI lives up to all the hype or not, it's clearly changing how we work, create, and solve problems. Understanding it feels essential.

I'm not trying to become an AI expert overnight - I'm just curious to understand what's possible and how these tools can enhance human creativity and productivity.

AI #MachineLearning #LearningInPublic #TechEducation #FreeCodeCamp #ArtificialIntelligence #TechExploration

This is part of my public learning journey. Follow along as I explore AI from complete beginner to... well, we'll see where this takes me!

🚀 Starting My 5-Month Java Full Stack Learning Journey - Learning in Public!

Tejasvi Urkande — Sat, 26 Jul 2025 08:26:51 +0000

Hey everyone! 👋

I'm committing to an intensive 5-month Java Full Stack learning journey and I'm going to share EVERYTHING publicly - the good, the bad, and the debugging sessions that make you question life choices! 😅

🎯 The Agenda

Master Java Full Stack development through a project-based approach before 2025 ends. I already know the basics, but this time I'm diving deep into practical implementation and real-world problem solving.

📅 The Commitment

5 months of consistent learning and sharing:

Daily DSA practice for logic building.
Weekly deep dives into different tech stacks
Building projects to cement every concept
Documenting every struggle, breakthrough, and "aha!" moment

🗓️ Week 1 Focus: Spring Boot Fundamentals

Since I already know core Java, jumping straight into:

Spring Boot project setup and architecture
Dependency Injection deep dive
Building REST APIs
Daily DSA problems for logic building

📚 What I'll Share Weekly:

✅ Concepts learned & implemented
✅ Problems faced & solutions found

✅ Resources that actually helped
✅ Project progress with code examples
✅ Mistakes made (plenty of those!)

🔗 Where to Follow Along:

GitHub: Will share repository links
Twitter: Daily updates and quick wins

🤝 Why Learn in Public?

If you're starting a similar journey, you can follow along, learn from my mistakes, and we can grow together! The best way to solidify knowledge is to teach others.

Ready to build something amazing together?
Let's do this! 💪

Follow my journey and let's connect if you're on a similar path! Your support and questions will keep me accountable.

LearnInPublic #Java #SpringBoot #React #FullStackDevelopment #100DaysOfCode #TechJourney #OpenSource