Tarun Manjunath

Deployment Engineer

4years in Frontend

4repositories checked by code analysis

MiddleBackend Developer

3roles confirmed by code

Overview

Fullstack developer building research-focused web applications with an emphasis on backend orchestration and a polished frontend UI, operating at a senior-borderline level - strongest demonstrated skill is designing resilient AI-assisted retrieval and analysis pipelines as implemented in backend/src/pipeline/orchestrate.ts. The most proven skill is backend orchestration and server-state hygiene, shown by the multi-step pipeline, sanitization (backend/src/pipeline/1-decompose.ts) and resilient Semantic Scholar retrieval (backend/src/lib/semanticScholar.ts). There is limited public evidence of systematic automated test coverage across the main application, formal accessibility engineering for custom widgets, or measured performance tuning and profiling artifacts.

Timeline

Deployment Engineer · Middle

Preneurs - Forward · Full-Time

Oct 2025 to Present 1 Year 1 Month Bengaluru In office

Worked with university customers to translate institution workflows into configurable SaaS modules and delivered end-to-end onboarding. Owned engagements from discovery and solution design through AWS deployment and post-deployment support, completing multiple customized production deployments within short timelines. Built and maintained a Node.js backend with a PostgreSQL data layer, including authentication and role-based access controls. Integrated Gemini into production workflows by retrieving relevant context via the backend before generating AI responses.

Node JS

PostgreSQL

Amazon S3

AWS

Forward Deployment Engineer · Middle

Preneurs · Full-Time

Jan 2026 to Present 10 Months In office

Worked with university customers to translate institution-specific workflows into configurable SaaS modules. Owned engagements end-to-end from discovery and solution design through customization, AWS deployment, onboarding, and post-deployment support, delivering multiple production deployments. Built a Node.js backend with PostgreSQL data structures and APIs to support institution workflows. Integrated Gemini into production workflows by using backend-retrieved application and database context to generate context-aware responses.

Node JS

PostgreSQL

AWS

Rest API

Software Development Engineer – Frontend · Middle

IDC Technologies Inc · Full-Time

Oct 2022 to May 2025 2 Years 7 Months In office

Developed and optimized React UI features to improve user engagement. Configured and deployed REST APIs to improve system connectivity and reduce API response times. Partnered with teams to optimize database responsiveness and reduce load times. Supported consistent releases and code quality through a CI/CD pipeline meeting high standards.

React.js

JavaScript

Rest API

CI/CD

Technical skills

Languages

JavaScript

TypeScript

Node JS

SQL

DevOps

Rest API

AWS

CI/CD

Amazon S3

Frontend

React.js

Tailwind CSS

Zod

React Router

Other

PostgreSQL

Express

Axios

MySQL

Redux

Prisma

Vite

Git

NLP

Middle Backend Developer Confidence: Medium API Engineer

Backend-focused engineer (mid-level) who composes modular AI-assisted retrieval and reasoning pipelines; their strongest asset is building auditable pipelines that combine external literature retrieval with deterministic, validated reasoning. The strongest proven skill is designing modular AI+retrieval integration with safety gates and persistence, evidenced by src/lib/ai.ts, src/lib/semanticScholar.ts, and the pipeline/*.ts orchestrated in src/pipeline/orchestrate.ts. There is little public evidence of production-grade observability, large-scale distributed systems, explicit migration history, or advanced DB transaction management.

API Design

3/10

How well APIs are designed

API-level decisions exist (sanitization, structured overrides) but there is little evidence of full API contract/versioning, idempotency keys, or comprehensive error-contract design across endpoints.

Evidence

tarun94m/Orbiis/backend/src/pipeline/orchestrate.ts: structuredIdeaOverride handling and client-sanitization comment tarun94m/Orbiis/backend/src/pipeline/1-decompose.ts: sanitizeStructuredIdea enforces invariants on client-provided structured ideas tarun94m/Orbiis/frontend/src/api.ts: runDecompose / runStressTest client functions (API usage surface)

Data Layer & Database

3/10

Working with databases

Uses Prisma and upserts for persistence and deduplication but there is no visible migration history, explicit transaction boundaries, or advanced tuning (indices/raw SQL) in the analyzed files.

Evidence

tarun94m/Orbiis/backend/package.json: prisma devDependency and prisma scripts tarun94m/Orbiis/backend/src/pipeline/orchestrate.ts: db.paper.upsert and db.ideaPaper.upsert usage tarun94m/Orbiis/backend/src/pipeline/orchestrate.ts: db.analysisRun.create persists outputJson

Scalability & Performance

2/10

Handling load and speed

Some pragmatic rate-limit/backoff and retry logic exists for external calls, but there is no evidence of caching strategy, queue-based decoupling, load-testing artifacts, or measured performance tuning.

Evidence

tarun94m/Orbiis/backend/src/lib/semanticScholar.ts: 429 basic backoff-and-retry for Semantic Scholar tarun94m/Orbiis/backend/src/lib/ai.ts: retry-on-parse-failure logic in generateJSON

System Architecture

4/10

Overall system structure

Clear modular pipeline decomposition and a provider abstraction for AI show deliberate architecture and separation of concerns, but service boundaries remain within a single-process backend without multi-service contracts or complex inter-service orchestration.

Evidence

tarun94m/Orbiis/backend/src/pipeline/orchestrate.ts: orchestrates numbered pipeline steps across modules (1-decompose..8-refinement) tarun94m/Orbiis/backend/src/lib/ai.ts: AI provider abstraction (GeminiProvider, buildProvider) encapsulating provider selection

Security & Auth

4/10

Protecting data and access

There is visible security awareness: input sanitization, secret validation, and defensive handling around external APIs, but comprehensive auth lifecycle, secrets rotation or dependency-audit artifacts are not present in the analyzed code.

Evidence

tarun94m/FullStack-OIDC/Backend/src/ConsentKeysPseudonymGenerator.js: validateSecretKey, validateInputs, null-byte checks and verifyPseudonym tarun94m/Orbiis/backend/src/pipeline/1-decompose.ts: sanitizeStructuredIdea enforces safe coercion of client/AI outputs

Reliability & Observability

3/10

Stability and monitoring

Pragmatic reliability patterns (retry, limited backoff, safe failure propagation) are implemented in places, but structured observability (metrics, traces, correlation ids), graceful shutdown patterns and advanced resiliency (circuit breakers, backpressure) are not evident.

Evidence

tarun94m/Orbiis/backend/src/lib/semanticScholar.ts: catches per-query errors and logs them rather than failing the whole retrieval tarun94m/Orbiis/backend/src/lib/ai.ts: retries once on unparsable AI JSON with a corrective prompt tarun94m/Orbiis/backend/src/pipeline/orchestrate.ts: explicit error thrown when no papers are returned to avoid inventing output

Expertise

Backend AI & LLM· Middle

Databases & Vector Storage· Middle

Microservices & API Architecture· Middle

Node.js· Middle

Technologies

Node JS· since 2025 · Middle

Rest API· since 2022

Express

Prisma

Axios

Recommendations

Develop AI-assisted research tooling and literature-review pipelines that require careful evidence provenance and sanitization.
Build privacy-preserving identity utilities and secure pseudonymization components for OIDC-like systems, leveraging the pseudonym generator patterns present.
Implement API-driven Node.js backends with Prisma for projects requiring upserts/deduplication and persistent audit trails.
Expand reliability and observability work: add structured logging, metrics, tracing, migrations, and transactional boundaries for production readiness.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Orbiis FullStack-OIDC The-Alter-Office

Middle Frontend Developer Confidence: High Fullstack

UI Component Architecture

3/10

How interface parts are built

Component architecture shows some custom hooks and deliberate CSS/token choices but lacks a visible, original component library or non-trivial composition patterns in the inspected files.

Evidence

The-Alter-Office/src/hooks/use-toast.ts: custom toast hook implementing global dispatch/listener state

Orbiis/frontend/src/styles.css: design tokens and global styling used across UI

Responsive & Cross-browser

4/10

Works on all screens and browsers

Responsive work is deliberate with fluid type, clamp(), media queries and Tailwind container configuration, but advanced feature-detection or RTL/i18n readiness is not evident.

Evidence

Orbiis/frontend/src/styles.css: uses clamp() for hero heading and multiple @media queries for responsive layouts

The-Alter-Office/tailwind.config.ts: container/padding and responsive screen definitions

Performance Optimization

3/10

Speed of the interface

Practical performance-aware patterns are present (deduping, basic backoff/retry, careful DB upserts) but there is no measurable before/after profiling, bundle analysis, or heavy optimizations like virtualization or advanced code-splitting in the reviewed files.

Evidence

Orbiis/backend/src/lib/semanticScholar.ts: basic retry on 429 and deduplication via Map in searchMultiple

Orbiis/backend/src/pipeline/orchestrate.ts: pipelined retrieval + db upserts rather than naive requerying

Accessibility & Semantics

2/10

Usable for everyone

Some a11y-minded CSS (focus-visible outlines) and semantic structure exist, but there is little evidence of ARIA on custom widgets, keyboard handling tests, or CI accessibility tooling.

Evidence

Orbiis/frontend/src/styles.css: textarea:focus and button:focus-visible styles

The-Alter-Office/public/index.html: reasonable document meta and responsive viewport tag

State Management & Data Flow

5/10

Managing data in the app

Clear server-state discipline and orchestration are present - structured decomposition, sanitization, resilient retrieval, deterministic persistence and end-to-end pipeline wiring show thought-through data flow and error handling.

Evidence

Orbiis/backend/src/pipeline/orchestrate.ts: end-to-end pipeline calling decompose, retrieve, selectClosestWork, buildContributionMap, detectCollisions, generateReviewerAttack, generateRefinement and persisting runs

Orbiis/backend/src/pipeline/1-decompose.ts: sanitizeStructuredIdea enforces invariants and fallback search query construction

Orbiis/backend/src/lib/semanticScholar.ts: searchMultiple handles per-query errors and deduplicates results

UX & Visual Polish

5/10

Look and feel quality

UX and visual polish are strong for a product-focused UI with many deliberate states, status badges, loading and print styles, and structured report layout, though some advanced perceived-performance techniques are not shown.

Evidence

Orbiis/frontend/src/styles.css: extensive classes for loading-state, status-pill, stress-summary, paper-card and print styles

Orbiis/frontend/src/styles.css: input-panel form states, disabled button styling and detailed report-section layouts

Expertise

React· Middle

Frontend AI Integration· Middle

Frontend Architecture & Build Tools· Middle

Industries

Education· Middle

Cybersecurity· Middle

Technologies

Redux

Tailwind CSS

CI/CD· since 2022

Git

AWS· since 2025

React.js· since 2022

Vite

Zod

React Router

Amazon S3· since 2025

Recommendations

Own end-to-end features that connect AI-assisted backend pipelines to interactive UI components - e.g., implement editable structured-idea UX with optimistic updates and rollback tied to the existing pipeline.
Build a small test-suite and CI for the Orbiis pipeline functions (unit tests for sanitizeStructuredIdea, semanticScholar searchMultiple behavior and pipeline integration tests).
Add measurable performance telemetry and a simple bundle analysis report to guide client-side code-splitting for large pages (stress-summary/paper-grid).
Formalize accessibility checks for custom widgets (keyboard, ARIA, focus management) and add axe/eslint-plugin-jsx-a11y to CI

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Orbiis FullStack-OIDC The-Alter-Office

Middle QA Engineer Confidence: Medium Generalist

A middle-level full-stack TypeScript engineer and QA-minded developer focusing on small-service architecture and security-minded utilities. The strongest proven skill is building secure deterministic pseudonymization and defensive negative-path tests, evidenced by ConsentKeysPseudonymGenerator.js and its runTests.js harness. There is limited evidence of CI/test infrastructure, contract testing, formal performance testing, or organized bug-tracking in public code.

Test Automation Frameworks

2/10

Building automated tests

Minimal test automation artifacts: a single custom test runner and ad-hoc assertions, but no fixtures, parallelization, mock servers, or structured test infra.

Evidence

tarun94m/FullStack-OIDC/Backend/test/runTests.js: custom Node test runner with console assertions tarun94m/FullStack-OIDC/Backend/src/ConsentKeysPseudonymGenerator.js: in-file helper functions used by tests (no external fixture framework)

Test Coverage & Strategy

3/10

What and how to test

Some purposeful negative-path and boundary checks are present, but tests are informal, assertion-driven console scripts rather than automated unit/integration suites with coverage or risk-based structuring.

Evidence

tarun94m/FullStack-OIDC/Backend/test/runTests.js: explicit negative-path checks (empty inputs, invalid dataType, null byte injection) tarun94m/Orbiis/backend/src/pipeline/1-decompose.ts: sanitizeStructuredIdea enforces invariants and fallback logic for missing fields

API & Integration Testing

4/10

Testing how parts work together

Real integration with an external API (Semantic Scholar) with deduplication, retry-on-429 and transparent query-to-paper mapping shows practical API integration thinking, but no formal contract testing or schema-validation tooling.

Evidence

tarun94m/Orbiis/backend/src/lib/semanticScholar.ts: searchPapers with retry-on-429 and searchMultiple with deduplication and queryByPaperId mapping tarun94m/Orbiis/backend/src/pipeline/orchestrate.ts: retrieval flow and db upserts that persist API results

Performance & Load Testing

1/10

Testing speed under load

Only a simple micro-benchmark loop exists inside an ad-hoc test script; no load scenarios, thresholds, or tool-driven performance tests are present.

Evidence

tarun94m/FullStack-OIDC/Backend/test/runTests.js: loop generating 1000 pseudonyms and printing elapsed time

Bug Reporting & Analysis

1/10

Finding and describing bugs

Some defensive coding and local reproductions exist, but there are no public issue trackers, structured bug reports, root-cause analyses, or flaky-test investigations tied to commits.

Evidence

tarun94m/Orbiis/backend/src/lib/semanticScholar.ts: logs and try/catch around failing queries (local error-handling evidence) tarun94m/Orbiis/backend/src/pipeline/orchestrate.ts: explicit thrown error when no papers are retrieved (reproducible failure condition)

CI Test Integration

1/10

Running tests automatically

No CI configuration detected; only local package.json scripts and a custom test runner are present, indicating minimal CI/test integration.

Evidence

tarun94m/Orbiis/backend/package.json: dev/build/start scripts but no CI workflow tarun94m/FullStack-OIDC/Backend/package.json: test script invoking the local runTests.js runner

Expertise

API Testing & Contract Validation· Junior

SDET & Test Engineering· Junior

Industries

Artificial Intelligence· Middle

Software· Middle

Technologies

JavaScript· since 2022 · Middle

TypeScript· since 2025 · Middle

Recommendations

Own API integration test work for services that call external APIs, adding schema validation and contract-checking (e.g., JSON schema checks and explicit mismatch handling).
Build a repeatable test infrastructure: migrate the console runner to an automated unit/integration framework (Jest or Mocha) with fixtures, mocks and CI pipeline integration.
Develop lightweight contract tests and recorded API fixtures for Semantic Scholar integration to make retrieval behaviors reproducible and auditable.
Expand performance testing by introducing tool-driven load scenarios (k6 or Locust) and SLO-style thresholds for critical endpoints.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Orbiis FullStack-OIDC Gemini-AI

Job preferences

Work permits: India

Open to AI agents: they read this profile and start a dialog through Alionalion.io/@tarun-manjunath/mcp