Jobify is a freelance marketplace website that connects clients with freelancers. Clients can post jobs or projects, and freelancers can apply by submitting proposals. The platform makes it easier to collaborate, communicate, and manage work online. Its purpose is to provide a simple, transparent, and efficient hiring process. Overall, the system creates opportunities for freelancers while helping clients find skilled professionals.
Written By Saidul Islam Shehab , Shoaib Mugdho,Fahmid Siddique Ahmed
~25-September-2025
Members of AUST Robotics Club
Students of Department of Computer Science & Engineering, AUST
The main objective of this project is to build a platform that connects clients and freelancers in one place. It aims to provide an easy system for posting jobs, submitting proposals, and managing projects. Another goal is to ensure transparency and trust between both parties. The website also seeks to create more opportunities for freelancers to showcase their skills. Finally, the project demonstrates how web technologies can be applied to solve real-world problems in online employment. It also focuses on creating a user-friendly interface so that both clients and freelancers can interact smoothly. In addition, the system is designed to support scalability for future improvements and advanced features.
Jobify is developed using the MERN stack, a robust and popular technology stack for building modern, full-stack web applications. The architecture is based on a classic three-tier client- server model, which decouples the user interface from the business logic and data storage.
Client-Side (Frontend): Built with React, the frontend operates as a Single Page Application (SPA). This means the user interface is rendered entirely in the browser. When a user interacts with the application, React components make asynchronous API calls to the backend to fetch or modify data, updating the UI dynamically without needing to reload the entire page.
Server-Side (Backend): The backend is powered by Node.js and the Express.js framework. It serves as a RESTful API that handles all business logic, user authentication, and data processing. It acts as the intermediary between the client and the database.
Database: MongoDB, a NoSQL document-oriented database, is used for data persistence.
Mongoose is utilized as an Object Data Modeling (ODM) library to define schemas for the
data and manage the interactions between the backend application and the MongoDB database.
To illustrate how tasks are carried out within the system, the following flowcharts detail the
primary user interactions.
Client: Posts a new job opportunity.
Freelancer: Browses available jobs and places a bid on a project they are interested in.
Data is structured using Mongoose schemas to ensure consistency and validation. The core
collections in the MongoDB database are:
Users Collection: Stores user information, including name, email, password (hashed), role
(client or freelancer), and profile details like skills, portfolio, etc.
Jobs Collection: Contains all job postings. Fields include title, description, budget, requiredSkills, status (e.g., open, in-progress, completed), and a reference to the client (User ID) who posted it.
Bids Collection: Represents proposals made by freelancers. It stores the proposal text, bidAmount, and references to the job (Job ID) and the freelancer (User ID) who made the bid.
The Jobify platform implements a range of features to facilitate the interaction between clients and freelancers. The backend exposes a set of RESTful API endpoints that the React frontend consumes to perform CRUD (Create, Read, Update, Delete) operations and handle business logic.
User Authentication and Authorization
This feature provides secure access to the platform, ensuring that users can only access data and functionality relevant to their role. This feature provides secure access to the platform, ensuring that users can only access data and functionality relevant to their role.
Registration: New users can create an account as either a 'Client' or a 'Freelancer'.
o API Endpoint: POST /api/auth/register
o Usage: The frontend sends a POST request with the user's details (name, email, password, role). The backend validates the data, hashes the password, and creates a new user record in the database.
Login: Registered users can sign in to their accounts.
o API Endpoint: POST /api/auth/login
o Usage: The user's credentials are sent to this endpoint. The server validates them, and if successful, generates and returns a JSON Web Token (JWT).
Authorization: The generated JWT is stored on the client side and sent in the Authorization header of subsequent requests. A custom middleware on the backend verifies this token to authenticate and authorize the user for accessing protected resources.
Job Management (Client Role)
Clients have full control over the jobs they post on the platform.
Create Job: Clients can post new job opportunities with details like title, description, budget, and required skills.
o API Endpoint: POST /api/jobs
o Usage: A POST request containing the job details is sent from the client's 'Post a Job' form. The server saves this information as a new document in the jobs collection.
View My Jobs: Clients can view a dashboard listing all the jobs they have posted.
o API Endpoint: GET /api/jobs/my-jobs
o Usage: A GET request, authenticated with the client's JWT, fetches all jobs associated with their user ID.
Update & Delete Jobs: Clients can edit the details of their job postings or remove them.
o API Endpoints: PUT /api/jobs/:id, DELETE /api/jobs/:id
o Usage: The frontend uses the job's unique ID in the URL to send PUT (for updates) or DELETE requests to the respective endpoints.
Job Discovery and Bidding (Freelancer Role)
Freelancers can browse available projects and submit their proposals.
Browse Jobs: Freelancers can see a list of all currently open job postings.
o API Endpoint: GET /api/jobs
o Usage: This endpoint returns a list of all jobs with an 'open' status, which the frontend then renders for the freelancer. Filtering and search functionality can be built on top of this endpoint using query parameters (e.g., GET /api/jobs?skill=React).
Submit a Bid/Proposal: Freelancers can place a bid on a specific job.
o API Endpoint: POST /api/bids
o Usage: When a freelancer submits a proposal, a POST request is sent with the proposal text, bid amount, and the associated Job ID and Freelancer ID.
Proposal and Project Management
This feature allows clients to manage incoming proposals and the project lifecycle.
View Bids: Clients can see all the proposals submitted for one of their job postings.
o API Endpoint: GET /api/jobs/:jobId/bids
o Usage: By providing the jobId in the URL, the client can fetch all associated bids from the database.
Accept a Bid: Clients can accept a freelancer's proposal, which typically changes the job's status to 'in-progress'.
o API Endpoint: PUT /api/bids/:bidId/accept
o Usage: A PUT request to this endpoint triggers the business logic to accept the bid, notify the freelancer, and potentially reject other bids for the same project.
User Profile Management
Both clients and freelancers can manage their public profiles.
View and Update Profile: Users can update their personal information, skills, and portfolio.
o API Endpoints: GET /api/users/profile, PUT /api/users/profile
o Usage: A GET request retrieves the current user's profile data for display. A PUT request with the updated information is sent to persist the changes in the database.
The outcome of the work is a fully functional, dynamic, and responsive single-page web application that serves as a marketplace for clients and freelancers. Below are screenshots of key interfaces and sample data exchanges.
The Jobify project addresses key societal issues in employment and economic empowerment by providing a centralized digital marketplace.
Reducing Unemployment: Jobify helps skilled individuals—developers, designers, writers, and marketers—monetize their talents project by project, offering an alternative to traditional employment and lowering unemployment.
Economic Flexibility: By supporting the gig economy, the platform lets users set rates, choose projects, and manage schedules, benefiting students, parents, and those unable to work 9-to-5 jobs.
Supporting SMEs: Small businesses gain access to specialized talent without hiring full-time
staff, allowing them to innovate and compete with larger companies efficiently.
Equal Opportunity: Jobify removes geographical barriers, focusing on skills and reputation rather than location, enabling professionals from developing regions to work globally.
A two-pronged approach was implemented to measure carbon emissions: one on the client- side to provide real-time feedback to the user, and one on the server-side to analyze the footprint of each API transaction.
On the frontend, the react-carbon-footprint library was utilized to estimate the carbon emissions generated during a user's session. This library tracks the total bytes of network data transferred and provides an estimate of the associated CO2 equivalent.
On the backend, The Green Web Foundation's @tgwf/co2 library was implemented as an Express middleware. This tool calculates the carbon emissions for each API request based on the total data size of the request and response, using the Sustainable Web Design (SWD) model.
Code Snippet: Express Middleware server.js, this middleware intercepts every API call, calculates the bytes transferred, and logs the estimated carbon emissions.
// ... after calculating request and response bytes const totalBytes = requestBytes + responseBytes;
const greenHost = false; // Set to true if server uses renewable energy
// The actual calculation using the @tgwf/co2 library
const emissions = co2Emission.perByte(totalBytes, greenHost); console.log(`Estimated CO2 emissions: ${emissions.toFixed(3)} grams`);
The analysis indicates that carbon emissions are directly linked to the amount of data
transferred. To make Jobify more sustainable, several optimization strategies are proposed:
Efficient Data Transfer: Optimize API payloads by sending only essential data and implement pagination to reduce the size of initial data loads.
Asset Management: Compress assets like images, and minify CSS and JavaScript files to
lower the overall data transfer.
Caching: Use browser and server-side caching to prevent redundant data requests.
Green Hosting: Deploy the application on a hosting service powered by renewable energy
to significantly reduce the carbon footprint.
This project successfully delivered Jobify, a full-stack freelancing marketplace built with the MERN (MongoDB, Express.js, React, Node.js) stack. The platform provides a seamless, role- based experience for clients to post jobs and for freelancers to bid on them. Core functionalities, including secure user authentication, job and bid management, and profile customization, were fully implemented. The project also went beyond functional requirements to analyze its societal benefits in the context of the modern gig economy and its environmental impact by calculating and proposing strategies to minimize its carbon footprint.
While the current version of Jobify is a robust and functional application, there are several
features that could be implemented to further enhance its value and user experience:
Real-Time Chat: Integrate a messaging system using WebSockets (e.g., Socket.io) to enable instant communication between clients and freelancers.
Payment Gateway Integration: Implement a secure payment solution (e.g., Stripe, PayPal) to handle project payments, escrow services, and platform fees directly.
Rating and Review System: Add a feedback mechanism for users to rate and review each other after project completion, building a community based on trust and reputation.
Admin Dashboard: Develop a comprehensive administrative panel for platform oversight, user management, dispute resolution, and analytics.
Mobile Application: Create native mobile applications for iOS and Android to provide users with a more accessible and convenient on-the-go experience.
