Shiv Rai
Fullstack
TypeScript
C++
Python
JavaScript
Node JS
Solidity
C
API Design: 4/10
Security & Auth: 4/10
Reliability & Observability: 4/10
Active 2 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
A frontend app engineer (mid-level) with practical experience building API-backed chat UIs and cross-platform React code. The strongest proven skill is integrating a server-side AI endpoint with robust request handling and typed application-level errors as shown in lib/nugen.ts and the app/api/chat route. There is little public evidence of automated tests, accessibility audits, or large-scale performance optimization work.
Technical skills
Languages
7
TypeScript
C++
Python
JavaScript
Node JS
Solidity
C
Frontend
4
React.js
Next.js
Tailwind CSS
Framer Motion
Other
27
Figma
PostgreSQL
Express
RainbowKit
Ethers.js
Ethereum
React Native
Electron
IPFS
Viem
Wagmi
Rest API
Stellar
GitHub
PostCSS
Git
Vercel
Expo
Supabase
Foundry
Hardhat
RevenueCat
TheHive
GraphQL
autoprefixer
Rive
Smart Contracts
Projects
Colors
Created a colorful productivity mobile app released on Google Play using Expo. Implemented in-app payments using RevenueCat and wired purchases into the app experience. Delivered the product as part of Shippaton 2025.
EZ- MERN stack RainbowKit Wallet Circle CCTP EthersJS ENS Complete Cross-chain payments suite
Developed a cross-chain payments suite featuring cross-chain transfers plus split, auto, and payment request flows. Implemented supporting user features such as contacts/address saving and ENS-based integration, along with profile and transaction history views.
Built a full-stack web application with a space/cosmos theme. Implemented Supabase authentication and backend capabilities, including edge functions and scheduled cron jobs. Integrated Telegram bot functionality and subscription billing via Dodo Payments.
Timeline
Full Stack Blockchain Developer
•
Middle
Muterra Labs
•
Full-Time
Worked on a full-stack Web3 gaming application deployed on the HIVE blockchain. Designed and implemented a hybrid transaction flow to support one-time token deposits for in-game usage while reducing repeated wallet interactions. Helped build multi-chain integration capabilities and supported core gameplay features, backend services, and blockchain integrations.
Web Development Intern
•
Junior
Grootz
•
Internship
Led a team of developers to build a website using React, including coordinating task allocation, meetings, and progress reporting. Contributed to the Grootz Academy by turning Figma designs into responsive React interfaces.
React.js
Figma
Middle Backend Developer
Confidence: Medium API Engineer
Backend API engineer at a Middle level specializing in compact Node.js integrations with LLM backends. Proven skill integrating with LLM services is shown by lib/nugen.ts which implements environment-driven configuration, AbortController timeouts, upstream error mapping and endpoint extraction. There is little to no evidence of databases, migrations, extensive scalability engineering, or automated test coverage in the analyzed server-side code.
API Design
4/10
How well APIs are designed
API surface includes explicit input validation, a consistent JSON error contract and typed request/response shapes, but lacks versioning, idempotency keys, pagination and formal API docs.
Evidence
nugen-copilot/app/api/chat/route.ts: POST handler with JSON parse validation, message length checks, history filtering and uniform error responses
nugen-copilot/lib/types.ts: ApiError and ChatRequest/NugenReply interfaces defining the API contract
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
3/10
Handling load and speed
Some performance-minded choices exist such as request timeouts and limiting history size, but there is no caching, connection pooling, queueing, or documented scaling strategy.
Evidence
nugen-copilot/lib/nugen.ts: AbortController with TIMEOUT_MS and clearTimeout usage
nugen-copilot/app/api/chat/route.ts: history slicing to the last 20 turns to limit payload size
System Architecture
3/10
Overall system structure
Clear module separation between API routes, a small lib layer and typed models shows deliberate organization, but the overall architecture is compact and single-service without documented decomposition or inter-service contracts.
Evidence
nugen-copilot/app/api/chat/route.ts: API layer delegating work to lib/nugen.ts
nugen-copilot/lib/utils.ts and nugen-copilot/lib/types.ts: utility and type modules for shared logic
Security & Auth
4/10
Protecting data and access
Reasonable security hygiene for a small service: environment-based API key handling, upstream auth error mapping, and input validation are present, though token lifecycle, revocation and secrets rotation are not shown.
Evidence
nugen-copilot/lib/nugen.ts: checks for NUGEN_API_URL, NUGEN_MODEL_ID, NUGEN_API_KEY and maps 401/403 to UPSTREAM_AUTH
nugen-copilot/app/api/chat/route.ts: validation of JSON body and message length with specific error codes
Reliability & Observability
4/10
Stability and monitoring
Basic reliability and observability practices appear: explicit timeout handling, structured error types, and console logging, but there are no retries with backoff, metrics, or structured tracing shown.
Evidence
nugen-copilot/lib/nugen.ts: NugenError type, AbortController timeout handling, specific TIMEOUT and NETWORK error codes
nugen-copilot/app/api/chat/route.ts: consistent error responses and logging of unexpected errors
Expertise
Backend AI & LLM• Middle
Technologies
Rest API
GraphQL
Recommendations
- Develop small-to-medium API services that integrate with LLM/ML backends and expose clear error contracts and typed responses.
- Harden reliability by adding retries with exponential backoff and jitter, observability (metrics and traces), and configurable timeouts.
- Add a persistent data layer with migrations and tests when stateful features are required, and document schema evolution.
- Expand API design work to include versioning, idempotency keys for long-running operations, and client-facing pagination patterns.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium App Engineer
A frontend app engineer (mid-level) with practical experience building API-backed chat UIs and cross-platform React code. The strongest proven skill is integrating a server-side AI endpoint with robust request handling and typed application-level errors as shown in lib/nugen.ts and the app/api/chat route. There is little public evidence of automated tests, accessibility audits, or large-scale performance optimization work.
UI Component Architecture
2/10
How interface parts are built
Basic utility and hook organization exists but no evidence of a deliberate component library or complex composition patterns.
Evidence
nugen-copilot/lib/utils.ts: cn and uid utilities used across UI code
Colors/hooks/useThemeColor.ts: theme hook that centralizes color selection
Jostraca-math-toolkit/gen/templates/index.html: small template showing slot-based HTML structure
Responsive & Cross-browser
3/10
Works on all screens and browsers
Some cross-platform and responsive considerations (viewport, web hydration) but no advanced responsive strategies or RTL/i18n work shown.
Evidence
Jostraca-math-toolkit/gen/templates/index.html: meta viewport and labeled inputs
Colors/hooks/useColorScheme.web.ts: hydration guard for server/client color-scheme detection
nugen-copilot/tailwind.config.ts: present as a responsive tooling artifact
Performance Optimization
3/10
Speed of the interface
Reasonable network performance handling and timeouts at the API layer but no measured optimizations, bundle analysis, or advanced runtime tuning.
Evidence
nugen-copilot/lib/nugen.ts: AbortController with TIMEOUT_MS and explicit timeout error handling
nugen-copilot/lib/nugen.ts: mapping upstream status to explicit error codes to avoid retry storms
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility signals in small UI template (labels, aria-live) but no evidence of accessibility testing, custom widget focus management or ARIA on dynamic components.
Evidence
Jostraca-math-toolkit/gen/templates/index.html: uses label elements and output with aria-live="polite"
Jostraca-math-toolkit/gen/templates/index.html: explicit labeled inputs for controls
State Management & Data Flow
3/10
Managing data in the app
Clear, small-scale server-client data flow with typed message shapes and input validation, but no complex server-state/cache discipline or state machines.
Evidence
nugen-copilot/lib/types.ts: ChatTurn, NugenReply and typed request/response shapes
nugen-copilot/app/api/chat/route.ts: history filtering, validation, and length-limiting of chat turns
nugen-copilot/lib/nugen.ts: error classification (TIMEOUT, NETWORK, UPSTREAM) for request flow
UX & Visual Polish
2/10
Look and feel quality
Small UX niceties and utilities for code display exist but no systematic skeletons, undo patterns, or staged loading states are shown in code artifacts.
Evidence
nugen-copilot/lib/utils.ts: extractCodeBlocks and extractEndpoints to drive richer reply rendering
Jostraca-math-toolkit/gen/templates/index.html: simple interactive UI with result output and error handling
Verified artifacts
Expertise
React• Middle
Frontend AI Integration• Middle
Frontend Architecture & Build Tools• Middle
Technologies
JavaScript
TypeScript• since 2024 • Middle
Node JS
Tailwind CSS
Next.js
Express
Electron
Vercel
Figma• since 2024
Git
React.js• since 2024
PostCSS
Framer Motion
autoprefixer
Rive
GitHub
Emotion• mentioned only
GitHub• mentioned only
Recommendations
- Implement API-backed chat and developer-assistant features that require server-side integration and robust error handling.
- Build end-to-end SPA features with typed message flows, input validation, and small-scale state management.
- Work on cross-platform React projects that need pragmatic theming and runtime environment handling (web and native).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Game Developer
Confidence: Medium Generalist
A pragmatic full-stack TypeScript developer (middle level) focused on building desktop and web tooling and developer-facing utilities. The strongest proven skill is reliable platform/tooling engineering, demonstrated by the Electron main/preload convert-to-pgs pipeline and the document extraction/packaging code (pegasus/src/main/main.ts and services/*.ts). There is little to no public evidence of game-specific systems, netcode, custom rendering shaders, or formal performance profiling data.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
1/10
Drawing game visuals
Frontend UI and theming code for mobile and web is present but there are no custom shaders, render passes, or advanced rendering systems.
Physics & Math
Game physics and math
Not evidenced in public code
Engine Proficiency
4/10
Skill with the game engine
Clear engine and platform proficiency: Electron app main/preload with secure contextBridge IPC, Next.js server API route with robust error mapping, and mobile Android/Expo Gradle configuration show work beyond default templates.
Evidence
ShivRaiGithub/pegasus/src/main/main.ts: Electron main process with IPC handlers and app lifecycle management
ShivRaiGithub/pegasus/src/main/preload.ts: contextBridge exposing typed IPC surface for renderer
ShivRaiGithub/nugen-copilot/app/api/chat/route.ts: Next.js server route with input validation and error mapping
Performance & Frame Budget
2/10
Keeping the game smooth
Some attention to robustness and latency: request timeout/AbortController use and careful PDF page iteration are present, but there are no profiler metrics, zero-alloc hot-paths, or advanced frame-budget optimizations.
Content Pipeline & Tooling
4/10
Tools for game content
Authoring of a content pipeline and tooling is evident: document extraction, translation orchestration with progress events, and a versioned .pgs packaging format demonstrate practical pipeline design and error handling.
Evidence
ShivRaiGithub/pegasus/src/main/services/pgsManager.ts: createPgsFile and readPgsFile implementing a versioned .pgs package format
ShivRaiGithub/pegasus/src/main/main.ts: convert-to-pgs flow with translation orchestration and IPC translation-status events
ShivRaiGithub/pegasus/package.json: Electron build/dev scripts supporting desktop tool distribution
Recommendations
- Use the developer to build desktop productivity or developer tooling that needs file I/O, format conversion, and an Electron-based UI.
- Assign them to implement LLM-backed developer workflows or API assistant UIs that require robust server-side request handling and error mapping.
- Have them extend document processing pipelines, adding new import/export formats, translation integrations, or packaging/version migrations.
- Engage them to harden platform integrations (Electron, Next.js, React Native) and to implement secure IPC and configuration handling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: