Frontend Engineering
Product Engineering
Braudit
Frontend engineering for a multi-tenant SaaS platform helping organizations manage employee productivity, tasks, goals, and performance.
- React
- TypeScript
- GraphQL
- Apollo Client
- GraphQL Code Generator
Frontend Engineering
Product Engineering
Jundaro
Jundaro is a freelance marketplace designed to connect clients with professionals and provide the tools needed to manage projects, applications, communication, and transactions. I worked as a Frontend Developer, building interfaces and workflows for clients, freelancers, and platform administrators. My contributions included project applications, transaction management, dispute handling, real-time messaging, and administrative dashboards. I also collaborated with backend engineering to improve dashboard data delivery, reducing manually observed loading times from approximately 4–6 seconds to around 1 second. I implemented Sentry monitoring to improve visibility into frontend issues in production.
Project details
- Project type
- Freelance Marketplace
- Role
- Frontend Developer
- Engagement
- Contract · Remote
- Period
- September 2024 – January 2025
- Status
- Engagement completed
- Technologies
- React
- TypeScript
- TanStack Query
- Socket.IO
- REST APIs
- Sentry
Context
Project context.
Jundaro is a freelance marketplace connecting clients who need professional services with freelancers seeking project opportunities. The platform brings several stages of freelance collaboration into one application, including project discovery and applications, client-freelancer communication, transaction management, dispute handling, and administrative oversight. Three distinct user groups interact with the platform. Clients manage their projects and engage freelancers, freelancers apply for opportunities and coordinate work, and administrators oversee marketplace activities through dedicated management interfaces. My involvement focused on frontend development across these experiences, building application workflows and integrating backend services. An important part of the engagement was improving dashboard performance. Existing dashboard views depended on multiple data requests, contributing to loading times of approximately 4–6 seconds. I worked with backend engineering to consolidate the required data into page-specific API responses, with manual checks subsequently showing loading times of around 1 second.
Project setting
Jundaro required frontend functionality for multiple roles within the same marketplace. Although the platform served a shared business purpose, clients, freelancers, and administrators interacted with different information and required different workflows. My work involved implementing these experiences, connecting them to backend services, handling real-time communication, and improving how application data was delivered to dashboard interfaces.
Problem space
- Clients needed interfaces for managing projects, reviewing applications, and communicating with freelancers.
- Freelancers needed workflows for applying to projects, managing engagements, and interacting with clients.
- Transactions and disputes required structured interfaces that made their information and status accessible to relevant users.
- Real-time messaging needed to support communication within the marketplace.
- Administrators needed dashboard interfaces for overseeing marketplace activities and managing platform operations.
- Dashboard pages were experiencing unnecessary loading delays due to how data was retrieved.
- Production frontend issues needed a consistent monitoring mechanism.
Target users
- Clients hiring freelancers for projects and professional services.
- Freelancers searching for opportunities and managing client engagements.
- Marketplace administrators overseeing transactions, disputes, and platform activities.
Contribution
My contribution.
I worked as a Frontend Developer on Jundaro from September 2024 to January 2025, implementing client, freelancer, and administrator workflows. My responsibilities included building marketplace interfaces, integrating REST APIs, implementing real-time messaging, supporting transaction and dispute management, improving dashboard performance, and configuring frontend error monitoring.
My contribution covered the core interfaces through which users interacted with the marketplace. I developed frontend workflows supporting project applications and ongoing client-freelancer interactions, alongside administrative interfaces used to manage marketplace operations. I also contributed to technical improvements beyond feature delivery, particularly dashboard data loading and production error visibility.
Client and Freelancer Workflows
Built frontend interfaces supporting client and freelancer activities across the marketplace, including project applications and engagement-related workflows. Implemented the UI interactions and backend integrations needed for users to access and manage relevant project information.
Transaction and Dispute Management
Developed frontend experiences for viewing and managing transaction-related information and disputes. Integrated the interfaces with backend services to support marketplace workflows while presenting information appropriate to the relevant user roles.
Real-Time Messaging
Implemented real-time messaging functionality using Socket.IO, supporting communication between users within the marketplace. Integrated messaging behavior into the frontend alongside the application's existing data-fetching and state-management patterns.
Administrator Dashboards
Built and supported administrative interfaces for marketplace management, including dashboards, reporting views, and oversight of platform activities. Integrated administrative data with frontend components to make information accessible through structured management interfaces.
Dashboard Performance Optimization
Identified opportunities to improve dashboard loading by reducing the number of separate requests required to populate individual pages. Collaborated with backend engineering to consolidate dashboard data into page-specific API responses. Manual checks showed loading times improving from approximately 4–6 seconds to around 1 second.
Production Error Monitoring
Integrated Sentry to improve visibility into frontend errors encountered in production. This provided a mechanism for identifying and investigating application issues beyond local development.
Scope of ownership
The engagement involved implementing both user-facing marketplace functionality and administrative tools. TanStack Query supported frontend data fetching and server-state management, while Socket.IO enabled real-time messaging. REST API integrations connected the frontend to marketplace services. A significant technical contribution was coordinating with backend engineering to improve dashboard data delivery rather than relying exclusively on frontend-level loading optimizations.
Implementation
Technical breakdown.
Jundaro's frontend combined role-specific marketplace interfaces, asynchronous data management, real-time communication, and administrative dashboards. The implementation used React and TypeScript, with TanStack Query for server-state management, REST APIs for backend integration, Socket.IO for real-time messaging, and Sentry for frontend error monitoring. The most notable performance improvement involved changing how dashboard data was requested. By collaborating with backend engineering on page-specific responses, I helped reduce loading delays and simplify the data required by individual dashboard views.
Marketplace Applications and User Workflows
- React
- TypeScript
- TanStack Query
- REST APIs
Implemented frontend workflows for clients and freelancers, covering project applications and interactions relevant to their marketplace roles.
The interfaces connected to backend services to retrieve and update the information needed for users to participate in projects and manage related activities.
Built these workflows within the broader application, maintaining consistency between role-specific interfaces and shared marketplace functionality.
- Client-facing project workflows.
- Freelancer project applications.
- Role-specific marketplace interfaces.
- Backend API integration.
- Asynchronous data fetching and updates.
Transactions and Dispute Interfaces
- React
- TypeScript
- TanStack Query
- REST APIs
Developed frontend functionality for marketplace transactions and disputes.
These interfaces provided users with access to transaction-related information and dispute-management workflows within the application.
Integrated the frontend with the relevant backend endpoints, focusing on displaying and updating information through the marketplace interface.
- Transaction-related interfaces.
- Dispute-management workflows.
- Role-specific access to marketplace information.
- Backend data integration.
Real-Time Messaging
- React
- TypeScript
- Socket.IO
Implemented real-time messaging functionality using Socket.IO to support communication within the marketplace.
Integrated real-time communication into the React frontend so users could exchange messages as part of their interactions on the platform.
This functionality complemented the project's application and transaction workflows by supporting direct communication between marketplace participants.
- Socket.IO integration.
- Real-time message communication.
- Messaging interface development.
- Integration with existing marketplace workflows.
Administrative Dashboards and Reporting
- React
- TypeScript
- TanStack Query
- REST APIs
Developed and supported frontend interfaces for platform administrators, including management dashboards and reporting views.
These interfaces provided structured access to marketplace information and administrative functionality.
Integrated dashboard components with backend APIs and supported improvements to the way data was delivered to individual pages.
- Administrative dashboard interfaces.
- Marketplace management workflows.
- Reporting views.
- API-driven data presentation.
- Dashboard data integration.
Dashboard Data Loading Optimization
- React
- TypeScript
- TanStack Query
- REST APIs
Some dashboard pages required multiple API requests to retrieve the information needed for their initial display, contributing to loading times of approximately 4–6 seconds.
I worked with backend engineering to consolidate the required data into page-specific API responses.
This approach reduced the need for separate frontend requests to assemble dashboard information and improved how data was delivered to the relevant views.
In manual checks, dashboard loading improved to approximately 1 second. These were observed results rather than formal benchmark measurements.
- Identified dashboard data-loading bottlenecks.
- Collaborated on page-specific API responses.
- Reduced fragmented frontend data requests.
- Improved dashboard loading behavior.
- Compared loading times through manual checks.
Frontend Error Monitoring
- Sentry
- React
- TypeScript
Configured Sentry for production frontend error monitoring.
This introduced a dedicated mechanism for capturing application errors and supporting investigation of issues affecting users.
The integration complemented the application's existing development and maintenance workflows by providing visibility into problems encountered after deployment.
- Sentry frontend integration.
- Production error monitoring.
- Error investigation support.
Outcomes
What the work delivered.
My work on Jundaro contributed to frontend delivery across the marketplace's three primary user experiences: clients, freelancers, and administrators. The implemented functionality supported project applications, transactions, disputes, real-time messaging, and administrative management. I also helped improve dashboard loading performance through coordinated frontend and backend changes, with manual observations showing loading times decreasing from approximately 4–6 seconds to around 1 second. Sentry integration introduced production error monitoring to support ongoing investigation of frontend issues.
Deliverable
Three Role-Specific Application Experiences
Delivered frontend workflows supporting clients, freelancers, and platform administrators, covering core marketplace interactions and management functionality.
Measured impact
- User roles supported
- 3
Client, freelancer, and administrator experiences.
The interfaces covered project applications, transaction and dispute workflows, administrative management, and other marketplace activities.
Outcome
Improved Dashboard Loading Performance
Collaborated with backend engineering to consolidate dashboard data into page-specific API responses, improving manually observed loading times from approximately 4–6 seconds to around 1 second.
Measured impact
- Observed dashboard loading
- ~1 second
Previously approximately 4–6 seconds in manual checks.
The improvement came from coordinating frontend data requirements with backend API changes. The figures reflect manual observations, not controlled performance benchmarks.
Deliverable
Real-Time Marketplace Communication
Implemented Socket.IO-based real-time messaging interfaces to support communication between marketplace users.
Messaging functionality was integrated into the frontend alongside project and marketplace workflows.
Deliverable
Transaction and Dispute Management Interfaces
Built frontend workflows for presenting and managing transaction-related information and disputes within the marketplace.
These interfaces formed part of the broader client, freelancer, and administrator experiences.
Deliverable
Administrative Management and Reporting
Delivered administrative dashboard functionality and reporting interfaces to support oversight of marketplace activities.
The implementation included backend data integrations and participation in dashboard performance improvements.
Deliverable
Production Error Visibility
Integrated Sentry to support monitoring and investigation of production frontend errors.
The integration provided an error-monitoring capability for the application after deployment.