diff --git a/controllers/parcelController.js b/controllers/parcelController.js
new file mode 100644
index 0000000..745e5f5
--- /dev/null
+++ b/controllers/parcelController.js
@@ -0,0 +1,42 @@
+const Parcel = require("../models/ParcelModel");
+
+const getAllParcels = async (req, res) => {
+  try {
+    const parcels = await Parcel.find();
+    res.status(200).json(parcels);
+  } catch (error) {
+    console.error("Error fetching parcels:", error);
+    res.status(500).json({ error: "Internal Server Error" });
+  }
+};
+
+const createParcel = async (req, res) => {
+  try {
+    const {
+      parcelDescription,
+      parcelWeight,
+      parcelDimension,
+      status,
+      sender,
+      receiver,
+    } = req.body;
+
+    console.log(req.body, "body from backend");
+    const newParcel = new Parcel({
+      parcelDescription,
+      parcelWeight,
+      parcelDimension,
+      status,
+      sender,
+      receiver,
+    });
+
+    const savedParcel = await newParcel.save();
+    res.status(201).json(savedParcel);
+  } catch (error) {
+    console.error("Error creating parcel:", error);
+    res.status(500).json({ error: "Internal Server Error" });
+  }
+};
+
+module.exports = { getAllParcels, createParcel };
diff --git a/controllers/validationController.js b/controllers/validationController.js
new file mode 100644
index 0000000..2c396f5
--- /dev/null
+++ b/controllers/validationController.js
@@ -0,0 +1,68 @@
+const User = require("../models/UserModel");
+
+//const users = User.find({});
+//console.log(users, "this is users");
+
+const getAllUsers = async () => {
+  try {
+    const users = await User.find({}).exec();
+    return users;
+  } catch (error) {
+    throw error;
+  }
+};
+
+// This function should be inside an asynchronous context
+const fetchDataAndLog = async () => {
+  try {
+    const users = await getAllUsers();
+    //console.log(users);
+  } catch (error) {
+    console.error("Error fetching users:", error);
+  }
+};
+
+// Call the asynchronous function
+fetchDataAndLog();
+
+const validateUsers = async (req, res) => {
+  const { senderName, senderPhoneNumber, recipientName, recipientPhoneNumber } =
+    req.body;
+  //console.log(req.body, "this is from backend");
+
+  try {
+    // Validate sender
+    //console.log(User, "try block");
+    const sender = await User.findOne({
+      username: senderName,
+      phone: senderPhoneNumber,
+      //phone: parseInt(senderPhoneNumber, 10),
+    });
+    console.log(sender, "this is sender");
+
+    if (!sender) {
+      return res.status(400).json({ error: "Sender validation failed" });
+    }
+
+    // Validate receiver
+    const receiver = await User.findOne({
+      username: recipientName,
+      phone: recipientPhoneNumber,
+    });
+    console.log(receiver, "this is reciever");
+
+    if (!receiver) {
+      return res.status(400).json({ error: "Receiver validation failed" });
+    }
+
+    // Return the ObjectIds
+    console.log("reached res json");
+
+    res.json({ senderId: sender._id, receiverId: receiver._id });
+  } catch (error) {
+    console.error("Error during user validation:", error);
+    res.status(500).json({ error: "Internal Server Error" });
+  }
+};
+
+module.exports = { validateUsers };
diff --git a/models/ParcelModel.js b/models/ParcelModel.js
new file mode 100644
index 0000000..cfc706b
--- /dev/null
+++ b/models/ParcelModel.js
@@ -0,0 +1,31 @@
+const mongoose = require("mongoose");
+const uniqueValidator = require("mongoose-unique-validator");
+
+const parcelSchema = new mongoose.Schema({
+  parcelDescription: { type: String, required: true },
+  parcelWeight: { type: Number, required: true },
+  parcelDimension: {
+    length: { type: Number, required: true },
+    width: { type: Number, required: true },
+    height: { type: Number, required: true },
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ["awaiting pickup", "in transit", "delivered"],
+  },
+  sender: { type: mongoose.Types.ObjectId, required: true, ref: "User" },
+  receiver: { type: mongoose.Types.ObjectId, required: true, ref: "User" },
+  createdAt: { type: Date, default: Date.now },
+});
+
+parcelSchema.pre("save", async function (next) {
+  // Your pre-save logic here
+  // For example, you can modify the document or perform asynchronous operations
+
+  // Call the next middleware in the schema
+  next();
+});
+
+parcelSchema.plugin(uniqueValidator);
+module.exports = mongoose.model("Parcel", parcelSchema, "parcels");
diff --git a/routes/parcelRoutes.js b/routes/parcelRoutes.js
new file mode 100644
index 0000000..6c95f66
--- /dev/null
+++ b/routes/parcelRoutes.js
@@ -0,0 +1,11 @@
+const express = require("express");
+const router = express.Router();
+const parcelController = require("../controllers/parcelController");
+
+// Route to get all parcels
+router.get("/parcels", parcelController.getAllParcels);
+
+// Route to create a new parcel
+router.post("/parcels", parcelController.createParcel);
+
+module.exports = router;
diff --git a/routes/userRoutes.js b/routes/userRoutes.js
index 4f72b5a..f2b98e5 100644
--- a/routes/userRoutes.js
+++ b/routes/userRoutes.js
@@ -1,9 +1,9 @@
 // routes/userRoutes.js
-const express = require('express');
+const express = require("express");
 const router = express.Router();
-const UserController = require('../controllers/userController');
+const UserController = require("../controllers/userController");
 
-router.post('/signup', UserController.createUser);
-router.post( '/signin', UserController.signInUser);
+router.post("/signup", UserController.createUser);
+router.post("/signin", UserController.signInUser);
 
-module.exports = router;
\ No newline at end of file
+module.exports = router;
diff --git a/routes/validationRoutes.js b/routes/validationRoutes.js
new file mode 100644
index 0000000..b791b7c
--- /dev/null
+++ b/routes/validationRoutes.js
@@ -0,0 +1,13 @@
+const express = require("express");
+const router = express.Router();
+const validationController = require("../controllers/validationController");
+
+const { validateUsers } = require('../controllers/validationController');
+
+router.post("/validateUsers", validationController.validateUsers);
+// GET endpoint for testing
+router.get("/test", (req, res) => {
+  res.json({ message: "GET request to /api/validation/test is successful!" });
+});
+
+module.exports = router;
diff --git a/server.js b/server.js
index 876f932..aea99c1 100644
--- a/server.js
+++ b/server.js
@@ -1,20 +1,22 @@
 // server.js is the entry point for the application.
-const express = require('express');
-const mongoose = require('mongoose');
-const cors = require('cors');
-const bodyParser = require('body-parser');
-const winston = require('winston');
-const morgan = require('morgan');
-const helmet = require('helmet');
-const userRoutes = require('./routes/userRoutes');
-const { PORT } = require('./config/serverConfig');
-const { dbUri } = require('./config/dbConfig');
+const express = require("express");
+const mongoose = require("mongoose");
+const cors = require("cors");
+const bodyParser = require("body-parser");
+const winston = require("winston");
+const morgan = require("morgan");
+const helmet = require("helmet");
+const userRoutes = require("./routes/userRoutes");
+const parcelRoutes = require("./routes/parcelRoutes");
+const validationRoutes = require("./routes/validationRoutes");
+const { PORT } = require("./config/serverConfig");
+const { dbUri } = require("./config/dbConfig");
 
 const app = express();
 
 // Logger setup
 const logger = winston.createLogger({
-  level: 'info',
+  level: "info",
   format: winston.format.json(),
   transports: [
     new winston.transports.Console({ format: winston.format.simple() }),
@@ -25,27 +27,42 @@ const logger = winston.createLogger({
 app.use(cors());
 app.use(bodyParser.json());
 app.use(helmet());
-app.use(morgan('combined', { stream: { write: message => logger.info(message) } }));
+app.use(
+  morgan("combined", { stream: { write: (message) => logger.info(message) } })
+);
 
 // Connect to MongoDB
-mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true })
-  .then(() => logger.info('Connected to MongoDB'))
-  .catch(err => logger.error(err));
+mongoose
+  .connect(process.env.MONGODB_URI, {
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+  })
+  .then(() => logger.info("Connected to MongoDB"))
+  .catch((err) => logger.error(err));
 
 // Use the user routes
-app.use('/api/user', userRoutes);
+app.use("/api/user", userRoutes);
+
+//senderid, recieverid Validatio
+app.use("/api/validation", validationRoutes);
+// Use the parcel routes
+app.use("/api/sendParcel", parcelRoutes);
+
+app.use("/", (req, res) => {
+  res.send("Welcome to the server");
+});
 
 // Health check endpoint
-app.get('/health', (req, res) => res.status(200).send('OK'));
+app.get("/health", (req, res) => res.status(200).send("OK"));
 
 // Centralized error handling
 app.use((err, req, res, next) => {
   // Check for duplicate key error
   if (err && err.code === 11000) {
-    res.status(409).send({ error: 'Username already exists.' });
+    res.status(409).send({ error: "Username already exists." });
   } else {
     logger.error(err.stack);
-    res.status(500).send('Something broke!');
+    res.status(500).send("Something broke!");
   }
 });