Unleash Live: Skill Assessment - Fullstack Engineer

5 min read18th January, 2026

When I received this assessment from Unleash Live, I was genuinely intrigued. Building a 3D point cloud annotator wasn't your typical take-home assignment but a real engineering challenge that combined 3D visualization, user interaction, and cloud architecture. So I was very excited to build it.

The assessment offered multiple tiers for both persistence and deployment. I decided to aim for Tier 3 on both not because it was required, but because it was the more interesting and challenging path.

The Requirements

The core task was to build a web application that:

Loads and displays a 3D point cloud using Potree
Allows users to click any point and create an annotation marker
Lets users attach a text string (max 256 bytes) to annotations
Allows users to delete existing annotations
Persists annotations across page refreshes

For persistence, the assessment offered three tiers: localStorage (Tier 1), local backend with NoSQL (Tier 2), or AWS serverless with API Gateway + Lambda + DynamoDB (Tier 3).

For deployment, the tiers ranged from local dev server (Tier 1), to hosted services like Vercel (Tier 2), to AWS S3 static hosting (Tier 3).

I chose Tier 3 for both.

Frontend: Why React?

For the frontend, I chose React 19 with TypeScript. Here's my reasoning:

Component Architecture — React's component model provides better organization for complex UIs than vanilla JavaScript
Ecosystem — Extensive documentation, massive community, abundant resources for troubleshooting
Personal Expertise — 5 years of React experience ensures I can handle edge cases efficiently
React 19 Compiler — Automatic memoization means cleaner code without manual useCallback/useMemo
AI-Assisted Development — As encouraged in the assessment, I leveraged AI tools (Anthropic's Opus 4.5 model) to adapt Potree's vanilla JS patterns to React

For 3D rendering, Potree handles the point cloud visualization. The UI uses Radix UI for desktop dialogs and Vaul for mobile drawers making the app fully responsive.

Backend: AWS Serverless (Tier 3)

Instead of a traditional Express or long-running Node.js server, this project uses a fully serverless, cloud-native backend on AWS. The goal was to design a scalable backend using modern AWS primitives and Infrastructure as Code — something I had intentionally wanted to build end-to-end for a long time.

Service	Purpose
API Gateway (HTTP API)	Exposes REST endpoints and routes requests to Lambda functions
AWS Lambda (Node.js 22)	Executes all annotation CRUD logic in a stateless environment
DynamoDB	Persists annotations using on-demand pricing for cost efficiency
AWS SAM	Defines and deploys the entire infrastructure as code

The entire backend infrastructure is defined in a single template.yaml file. A single command sam deploy provisions and updates all cloud resources in a repeatable and auditable way.

API Endpoints

Method	Endpoint	Description
GET	/health	Health check endpoint to verify API availability
GET	/annotations?sceneId=x	Fetch all annotations for a specific scene
POST	/annotations	Create a new annotation at a 3D coordinate
PUT	/annotations/:id	Update an existing annotation by ID
DELETE	/annotations/:id	Delete an annotation permanently

Deployment: S3 + CloudFront (Tier 3)

The frontend is hosted as static files on AWS S3 with CloudFront as the CDN — exactly what Tier 3 requested. This provides:

Global edge caching for fast load times
HTTPS out of the box
Essentially infinite scalability
Cost: ~$0.50/month

Infrastructure as Code

The assessment mentioned that providing IaC would be "highly regarded." The backend is fully defined in AWS SAM's template.yaml:

# Creates Lambda, API Gateway, DynamoDB, and IAM roles
Resources:
  AnnotationsFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs22.x
      Handler: handlers/annotations.handler
      Events:
        GetAnnotations:
          Type: HttpApi
          Path: /annotations
          Method: GET

Anyone can clone the repo and deploy an identical stack with sam deploy --guided.

CI/CD: Automated Pipelines

Both the frontend and backend repositories are configured with GitHub Actions to enable fully automated build and deployment workflows. Each pipeline is designed to enforce code quality checks before deploying to production.

Frontend Pipeline

TypeScript type checking
ESLint validation
Production build
Deploy static assets to Amazon S3
Invalidate CloudFront cache

Backend Pipeline

TypeScript type checking
Application build
AWS SAM build
AWS SAM deploy

Every push to the

main

branch automatically triggers a production deployment. Pipeline execution details, logs, and artifacts can be reviewed in the Actions tab of each repository.

Acceptance Criteria

✅Point cloud loads correctly in the Potree viewer
✅Click any point in the scene to create an annotation
✅Input and persist annotation text (up to 256 bytes)
✅Delete existing annotations
✅Annotations reload correctly on page refresh
✅
Tier 3 persistence using AWS Lambda and DynamoDB
✅
Tier 3 deployment with S3 static hosting
✅
Infrastructure as Code implemented using AWS SAM

Try It

The application is live and all source code is public:

Live Demo: d1cw1dqgsb03xc.cloudfront.net
Frontend Repo: github.com/KushalRaut/pointcloud-fe
Backend Repo: github.com/KushalRaut/pointcloud-be

Each README contains clear instructions for local development or deploying your own instance.

Final Thoughts

This assessment was a great opportunity to build something beyond a typical CRUD app. Going for Tier 3 on both persistence and deployment pushed me to think about cloud architecture, Infrastructure as Code, and production-ready deployment pipelines.

The result is a fully functional, cloud-native application that costs under $1/month to run and scales automatically.