Skip to content
Tamal Sen

Open to relevant opportunities

Tamal Sen — Software Developer

Building practical web applications and reliable backend systems.

I develop web applications and backend systems using React, Node.js, Laravel, and modern database technologies, with a focus on useful functionality, maintainable code, and reliable software.

View ProjectsDownload ResumeContact Me
Core stack
  • React
  • Node.js
  • PostgreSQL
  • MongoDB
How I buildrequest flow
  1. InterfacePages & components
  2. APIEndpoints & auth
  3. DataSchema & queries

01About

Building useful software, from the database to the interface.

I'm a software developer at BlueHorse Software Solutions, based in West Bengal, India. I work on business web applications across the stack — React interfaces, Node.js backends, REST APIs, and the PostgreSQL and MongoDB databases behind them.

On AuditFlow, a lease-accounting application, I've worked directly with the client to understand requirements, clarify how features should behave, and turn them into implementation work — then tested, debugged, and refined features based on feedback. On a SaaS CMS management platform, I've built admin interfaces, backend functionality, and the APIs that connected websites use for their content.

My background also includes Laravel and PHP — MVC, Eloquent ORM, and Blade — along with WordPress development tasks. Outside work, I build personal projects such as Ledgerly and an Employee Management REST API to practise backend design: authentication, authorization, caching, and clear API structure.

I care about software that is genuinely useful, and code that the next developer can read and maintain.

02Skills

Technical skills

Grouped by where they sit in an application, and marked by how I've used them — at work, in personal projects, or as something I'm currently learning.

  • Used professionally
  • Used in personal projects
  • Currently learning

Frontend

Interfaces and client-side application logic.

  • React (used professionally)
  • JavaScript (used professionally)
  • HTML5 (used professionally)
  • CSS3 (used professionally)
  • Next.js (used in personal projects)
  • TypeScript (used in personal projects)
  • Tailwind CSS (used in personal projects)
  • Bootstrap (used in personal projects)

Backend

APIs, server-side logic, and authentication.

  • Node.js (used professionally)
  • REST APIs (used professionally)
  • PHP (used professionally)
  • Laravel (used professionally)
  • Express.js (used in personal projects)
  • JWT authentication (used in personal projects)

Databases & ORM

Relational and document data modelling.

  • PostgreSQL (used professionally)
  • MongoDB (used professionally)
  • SQL (used professionally)
  • Prisma ORM (used in personal projects)

Tools & deployment

Version control, servers, and hosting.

  • Git (used professionally)
  • GitHub (used in personal projects)
  • Linux (used in personal projects)
  • Nginx (used in personal projects)
  • PM2 (used in personal projects)
  • Vercel (used in personal projects)
  • Netlify (used in personal projects)
  • Docker (currently learning)
  • GitHub Actions (currently learning)

03Projects

Selected projects

Business applications I've worked on professionally, and independent projects that show how I approach backend and full-stack work.

Professional work

Built as part of my role at BlueHorse Software Solutions. Code and client details are confidential, so these are anonymised case studies.

Illustration of the platform's structure — no client data or real screens.

01Professional workBlueHorse Software Solutions

SaaS CMS Management Platform

Admin platform and content API for CMS-powered websites

A SaaS administrative platform and backend used to manage dynamic CMS-powered websites. The platform exposes APIs that connected websites consume to retrieve and manage their dynamic content.

My contributions

  • Developed React-based administrative interfaces.
  • Implemented Node.js backend functionality.
  • Developed and integrated REST APIs for dynamic website content.
  • Worked with PostgreSQL for data storage and retrieval.
  • Contributed to the functionality connecting the platform with its CMS-powered websites.
  • React
  • Node.js
  • PostgreSQL
  • REST APIs
Confidential client work — shown as an anonymised case study.
Case study— overview, my role, technical implementation
Overview

Content for several websites is managed from one administrative platform. Each connected website retrieves its dynamic content from the platform through REST APIs instead of storing it separately.

My role

Developer on the team, working across the React admin interface, the Node.js backend, and the content APIs.

Technical implementation
  • React admin screens for managing website content.
  • Node.js backend exposing REST endpoints to connected websites.
  • PostgreSQL for storing and retrieving content data.
Illustration of the delivery loop and a generic records view — no client data.

02Professional workBlueHorse Software Solutions

AuditFlow

Lease-accounting application

AuditFlow is a lease-accounting application supporting business accounting workflows and lease-related functionality. I worked with the client directly, from understanding requirements through implementation and refinement.

My contributions

  • Communicated directly with the client to understand business requirements.
  • Clarified functional requirements and expected application behaviour.
  • Translated requirements into technical tasks and implementation work.
  • Developed frontend functionality using React.
  • Implemented backend functionality using Node.js.
  • Worked with MongoDB for application data.
  • Tested features, debugged issues, and refined implementations based on feedback.
  • React
  • Node.js
  • MongoDB
Confidential client work — shown as an anonymised case study.
Case study— business problem, my role, requirements & communication, technical implementation
Business problem

Lease accounting depends on structured, rule-driven workflows around lease data. The business needed an application that supports those workflows in the way its accounting team actually works.

My role

Developer working directly with the client — gathering and clarifying requirements, then building, testing, and refining features across the React frontend and Node.js backend.

Requirements & communication
  • Discussed business requirements directly with the client.
  • Clarified expected behaviour before implementation.
  • Broke requirements down into technical tasks.
  • Refined features based on client feedback.
Technical implementation
  • React frontend for the application's workflows.
  • Node.js backend for application logic and APIs.
  • MongoDB for application data.

Personal projects

Independent projects, with source code and live demos where available.

Request pipeline: Request, then Rate limit, then Authenticate, then Authorize, then Controller, then PostgreSQL.

API endpoints
MethodPathAccess
POST/api/v1/auth/loginpublic
POST/api/v1/auth/refreshpublic
POST/api/v1/auth/logoutpublic
GET/api/v1/employees?page=&search=public
GET/api/v1/employees/:id
POST/api/v1/employeesadmin
DEL/api/v1/employees/:idadmin
GET/api/v1/audit-logsadmin
Selected endpoints and the request pipeline, taken from the repository.

03Personal project

Employee Management REST API

Node.js API with authentication, roles, caching, and audit logs

A REST API for employee data management, focused on authentication, access control, and a clean backend structure — routes, middleware, controllers, and utilities kept separate.

Key features

  • CRUD endpoints for employee records.
  • Paginated list endpoint with name search.
  • JWT access tokens plus refresh tokens stored server-side and revoked on logout.
  • Role-based authorization middleware for admin-only operations.
  • Zod-based request validation middleware.
  • Redis caching for list queries, cleared on writes, with a database fallback.
  • Audit log of create, update, and delete actions.
  • Node.js
  • Express.js
  • PostgreSQL
  • JWT
  • Zod
  • Redis
Source code
Engineering notes— problem, implementation, key decisions
Problem

An API that manages people data needs more than CRUD: list endpoints should stay responsive as records grow, only the right users should change data, and changes should be traceable.

Implementation
  • Express 5 app with versioned routes under /api/v1.
  • PostgreSQL via node-postgres with parameterised queries.
  • Passwords hashed with bcrypt; registration wrapped in a transaction.
  • Helmet security headers, rate limiting, and a central error handler.
Key decisions
  • Role checks live in reusable middleware rather than in each handler.
  • Refresh tokens are stored per user, so logout can revoke them.
  • Cache failures fall back to the database instead of failing the request.
Illustration of the dashboard layout — not a product screenshot.

04Personal project

Ledgerly

Personal finance dashboard

A personal finance dashboard for organising financial records and presenting them through a web interface. The React frontend and the Express API are deployed separately and communicate over REST.

Key features

  • Account sign-up and sign-in.
  • Dashboard overview of financial records.
  • Transactions that can be added, edited, and deleted.
  • Budgets and goals views.
  • Recurring payments and subscriptions, with suggested recurring transactions.
  • User-defined rules for organising transactions, and document uploads.
  • React
  • Vite
  • Tailwind CSS
  • Node.js
  • Express.js
  • Prisma
  • PostgreSQL
Live demo
Engineering notes— problem, implementation, key decisions
Problem

Financial records spread across bank apps, notes, and spreadsheets are hard to review together. Ledgerly keeps them in one place and organises them so spending is easier to understand.

Implementation
  • React single-page app built with Vite and Tailwind CSS, hosted on Vercel.
  • Node.js and Express REST API, deployed as a separate service.
  • Prisma schema and migrations over a PostgreSQL database.
Key decisions
  • Frontend and API are separate deployments, so each can be released independently.
  • Prisma keeps the schema, migrations, and query types in one place.

04Experience

Professional experience

  1. —

    Software Developer

    BlueHorse Software Solutions Pvt LtdMidnapore

    Full-stack development of business web applications.

    • SaaS CMS Management Platform

      • React
      • Node.js
      • PostgreSQL
      • REST APIs
      • Developed React administrative interfaces for managing website content.
      • Implemented Node.js backend functionality and REST APIs consumed by connected websites.
      • Worked with PostgreSQL for storing and retrieving content data.

    • AuditFlow — Lease Accounting

      • React
      • Node.js
      • MongoDB
      • Communicated directly with the client to gather and clarify requirements.
      • Translated requirements into technical tasks and implemented them in React and Node.js.
      • Worked with MongoDB for application data.
      • Tested features, debugged issues, and refined implementations based on feedback.

    • Laravel & WordPress

      • PHP
      • Laravel
      • WordPress
      • Laravel and PHP development training covering MVC, Eloquent ORM, and Blade templates.
      • Contributed to migrating an existing website to Laravel.
      • WordPress development tasks.

05Education

Education

  • Master of Computer Applications (MCA)

    MAKAUT / Dr. B. C. Roy Engineering College, Durgapur

    2024 CGPA 7.47 / 10

  • Bachelor of Computer Applications (BCA)

    ICIS College, Bankura

    2021 71.76%

06Process

How I approach software development

A repeatable sequence from understanding what's needed to delivering a working feature.

  1. 01

    Understand requirements

    Learn what the feature is for, who uses it, and what done looks like.

  2. 02

    Clarify behaviour

    Confirm expected behaviour, edge cases, and technical constraints.

  3. 03

    Plan the tasks

    Break the work into small, reviewable implementation tasks.

  4. 04

    Build

    Develop the frontend, backend, and database changes.

  5. 05

    Integrate

    Connect APIs and components, handling loading and error states.

  6. 06

    Test and refine

    Test the flows, debug issues, and refine based on feedback.

  7. 07

    Prepare for delivery

    Tidy up, verify the build, and hand over a working feature.

  8. Direct client communication and requirement gathering were part of my AuditFlow work. On other projects I've contributed to specific parts of this process as a member of the team.

07Contact

Get in touch

I'm interested in software developer, React, Node.js, backend, and full-stack roles, and happy to talk about freelance web projects. Email is the quickest way to reach me.

Based in West Bengal, India