← Back to history

Pipeline run

dfdebd26-442a-4d76-a05f-05d75b628284

Pipeline LLM cost (USD)
API 1: $0.0115 API 2: $0.0001 API 3: $0.0000 Total: $0.0117

Client output enrichment

v2 Skill cluster · Nature of work · AI index · Tech stack maturity · Evidence · KRA description
OVERLAP · android-engineer role baseline loaded sources · ai_index: jd · nature_of_work: jd · tech_stack_maturity: jd
Nature of work · Backend API integration
Build and ship React Native/TypeScript mobile features in a scrum team, wiring GraphQL/REST data flows, managing state, and using CI/CD, phased rollouts, and feature flags to release safely. You’ll also write Jest tests, review PRs, and troubleshoot performance and production issues. Also touches Android app build and development workflows.
"Experience with GraphQL and how GQL works vs REST api's"
Tech stack maturity
Mainstream Modern
The stack centers on React, TypeScript, Node.js, GraphQL, Jest, and CI/CD, which are widely adopted modern web and mobile development technologies.
AI index (0 = no AI use, 5 = totally AI-dependent · v2.1)
0.80 / 5
· Title match
· Has AI skill
· AI skill (primary)
· AI skill (secondary)
· On AI team
· Builds AI products
vocab breakdown (legacy)
Assistants (×1):
Frameworks (×2):
Models / concepts (×3):
Evidence — skills matched in JD (22)
React React Native TypeScript Jest GraphQL REST Node.js CI/CD React Query GitLab CI GitHub Actions CircleCI Objective-C Swift Java Kotlin Xcode Gradle Android Studio SAFe Scrum Code Review
Skill cluster (10 dimension groups, role-scoped)
API Integration and Data Fetching
GraphQL React Query
JavaScript and TypeScript
TypeScript Node.js
UI Frameworks and Rendering
React React Native
Build and Dependency Management
Gradle
Frontend Testing and E2E Automation
Jest
Integration Protocols & Standards
REST
Java Language and JVM
Java
Kotlin and Java
Kotlin
Native Mobile Build and Release Tooling
Xcode
Cross-cutting / unaligned
CI/CD GitLab CI GitHub Actions CircleCI Objective-C Swift Android Studio SAFe Scrum Code Review
Show KRA description ↓
Thorough production-proven knowledge of the React ecosystem. experience of React Native and Typescript (be able to demonstrate contribution to a product build with React native) · Experience with deploying mobile software: phased rollouts, feature flagging, CICD approach, build toolchain, App Store Connect, Play Store, … · Familiar with state management eg. React Query · Experience with automated testing suites like Jest Experience with GraphQL and how GQL works vs REST api's · Knowledge of Node.js · Familiar with one or more CI/CD environments: Gitlab CI, Github Actions, Circle CI, etc · Sufficient knowledge of the underlying native platform · (Obj-C/Swift/Java/Kotlin/Xcode/Gradle/Android Studio) · Working experience in a SAFe environment is a plus. 1 As part of a scrum team, you’ll contribute to the continuous development of the product features that are in the care of your team 2 Design and develop new user stories, create & review pull requests, document your work, perform research, communicate clearly about your progress 3 Troubleshoot issues and improve front-end performance 4 Together with your colleagues, you’ll make sure the product features meets all functional and non-functional requirement.

Signals

Skill full-stack-engineer
0.88
Alias
KRA full-stack-engineer
0.56

Post-classification

Centroidupdated · n=158
Alias collision log
New-role queue
New skills captured2
New KRA captured

Captured for admin review

Android Studio Frontend Developer pending
SAFe Frontend Developer pending
Status: completed Created: 2026-05-27T14:26:42.165835Z Updated: 2026-05-27T14:29:27.258560Z API 3 duration: 124311 ms
Flow Current 3-step pipeline

1 POST /skills/extract-from-jd

2 POST /skills/extract-details

3 POST /skills/final-role-output

Role Chosen role & resolution

Frontend Developer

React Frontend Developer

sub-role · 0.99 domain · Software Engineering CASE DOMAIN

slug: frontend-engineer · id: 7 · source: db · sub-role slug: react-frontend-developer

Domain=Software Engineering → sub-role react-frontend-developer; The JD is centered on React/TypeScript frontend development, with mobile and CI/CD concerns as supporting responsibilities.

Matched skills

ReactReact NativeTypeScriptReact QueryJestGraphQLREST APINode.jsGitlab CIGithub ActionsCircle CIApp Store ConnectPlay StoreObj-CSwiftJavaKotlinXcodeGradleAndroid Studio

Matched dimensions

React frontend developmentMobile app developmentCI/CD and release engineeringFrontend performance optimizationAutomated testingScrum-based product development

Matched KRAs

Contribute to the continuous development of product featuresDesign and develop new user storiesCreate and review pull requestsDocument your workTroubleshoot issues and improve front-end performanceEnsure product features meet functional and non-functional requirements

Resolution: in_db — role exists in library; skill↔dim and role↔dim links saved when applicable.

0
New skills
0
Skill↔dim saved
0
Role↔dim saved
0
Skipped

Job description

Greetings from TCS!!


Role: Lead Developer 
 Experience: 7 to 10 Years
Location: Hyderabad
Must-Have ·
Thorough production-proven knowledge of the React ecosystem. 


experience of React Native and Typescript (be able to demonstrate contribution to a product build with React native) · 
Experience with deploying mobile software: 
phased rollouts, feature flagging, CICD approach, build toolchain, App Store Connect, Play Store, … · Familiar with state management eg. React Query · 
Experience with automated testing suites like Jest
Good-to-Have · Experience with GraphQL and how GQL works vs REST api's · Knowledge of Node.js · Familiar with one or more CI/CD environments: Gitlab CI, Github Actions, Circle CI, etc · Sufficient knowledge of the underlying native platform · (Obj-C/Swift/Java/Kotlin/Xcode/Gradle/Android Studio) · Working experience in a SAFe environment is a
plus. 
Responsibility of / Expectations from the Role
1 As part of a scrum team, you’ll contribute to the continuous development of the product features that are in the care of your team
2 Design and develop new user stories, create & review pull requests, document your work, perform research, communicate clearly about your progress
3 Troubleshoot issues and improve front-end performance
4 Together with your colleagues, you’ll make sure the product features meets all functional and non-functional requirement.






If you are interested kindly share your update resume.




Thanks and Regards
Shincy Johnson

Skills from this JD

Each row merges API 1 extraction, API 2 library match / v3 orchestration (dimensions + locked dims), and API 3 persistence tags.

React Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: React id=610 · react

Aliases — catalog

  • React (CANONICAL) primary
  • React 0.13 (VERSION)
  • React 0.14 (VERSION)
  • React 15 (VERSION)
  • React 15.x (VERSION)
  • React 16 (VERSION)
  • React 16.x (VERSION)
  • React 17 (VERSION)
  • React 17.x (VERSION)
  • React 18 (VERSION)
  • React 18.x (VERSION)
  • React 19 (VERSION)
  • React v15 (VERSION)
  • React v16 (VERSION)
  • React v17 (VERSION)
  • React v18 (VERSION)
  • React v19 (VERSION)
  • ReactJS 18 (VERSION)
  • react 15 (VERSION)
  • react 16 (VERSION)
  • react 17 (VERSION)
  • react 18 (VERSION)
  • react 19 (VERSION)
  • react15 (VERSION)
  • react16 (VERSION)
  • react17 (VERSION)
  • react18 (VERSION)
  • react19 (VERSION)
  • reactjs 18 (VERSION)

Context tags (catalog)

Babel Class Components Component Lifecycle Context API Functional Components Higher-Order Components Hooks JSX Next.js PropTypes Props React Native React Router Redux SSR State Management Styled Components Testing Library TypeScript Virtual DOM Webpack component lifecycle context API frontend hooks props state management useEffect useState virtual DOM

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Frontend Framework
Vendor
Meta
License
mit
Year introduced
2013
Confidence
0.98
Version strategy
SEPARATE_ENTITY
Version tag
18

Maturity reasoning: React appears in high-volume frontend job postings across startups and enterprises and remains a default hiring-pipeline skill, with strong GitHub/npm usage and ecosystem activity.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
1072
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Application Frameworks & Libraries Catalog dimension db id 451

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Frontend Frameworks and Libraries Catalog dimension db id 434

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

  • JavaScript for WordPress Catalog dimension db id 329

    Library dimension (catalog)

    Roles linked in library: WordPress Dev

  • React Component Architecture Catalog dimension db id 302

    Library dimension (catalog)

    Roles linked in library: React Frontend Developer

  • UI Frameworks and Rendering Catalog dimension db id 115

    Library dimension (catalog)

    Roles linked in library: Frontend Developer, Fullstack Developer, Fullstack Developer, Hybrid Mobile Developer, Ionic Developer, Web Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Frontend Frameworks and Libraries
frontend-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Component Architecture
react-component-architecture
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
React Native Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: React Native id=1040 · react-native

Aliases — catalog

  • React Native (CANONICAL) primary

Context tags (catalog)

Android Component Lifecycle Cross-Platform Expo Firebase GraphQL Hooks Hot Reloading JavaScript Jest MobX Mobile UI Native Modules REST API React Hooks React Navigation Redux State Management Styled Components TypeScript UI Kitten iOS

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Mobile App Framework
Vendor
Meta
License
mit
Year introduced
2015
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: React Native appears in many mobile engineer job descriptions and is widely used in production apps by major vendors, indicating strong hiring-pipeline demand rather than niche adoption.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
2146
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cross-Platform Mobile UI Frameworks Catalog dimension db id 319

    Library dimension (catalog)

    Roles linked in library: React Native Developer

  • UI Frameworks and Rendering Catalog dimension db id 115

    Library dimension (catalog)

    Roles linked in library: Frontend Developer, Fullstack Developer, Fullstack Developer, Hybrid Mobile Developer, Ionic Developer, Web Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cross-Platform Mobile UI Frameworks
cross-platform-mobile-ui-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
TypeScript Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: TypeScript id=524 · typescript

Aliases — catalog

  • TypeScript (CANONICAL) primary
  • TypeScript 5 (VERSION)
  • TypeScript 5.x (VERSION)
  • ts (VERSION)
  • ts5 (VERSION)
  • typescript 5 (VERSION)
  • typescript 5.x (VERSION)
  • typescript5 (VERSION)

Context tags (catalog)

Angular Async/Await Decorator Deno ESLint Generics GraphQL Interfaces JavaScript Jest NestJS Next.js Node.js Promise React Redux RxJS TypeORM Vite Vue Vue.js Webpack async/await decorators generics interfaces module resolution npm strict mode tsconfig type annotations type guards type inference type safety yarn

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Microsoft
License
apache_2
Year introduced
2012
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: TypeScript is a hiring-pipeline staple: it appears in a large share of modern web/frontend and Node.js job descriptions, and major frameworks like Angular and Next.js recommend it by default.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cross-Platform App Languages Catalog dimension db id 167

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer

  • JavaScript and TypeScript Catalog dimension db id 114

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer, Frontend Developer, Ionic Developer, Node.js Backend Developer, React Frontend Developer, React Native Developer, Svelte Frontend Developer, Vue Frontend Developer, Web Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer, Fullstack Developer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension saved
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Query Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: React Query id=1411 · react-query

Aliases — catalog

  • React Query (CANONICAL) primary
  • react query 4 (VERSION)
  • react query 5 (VERSION)
  • react-query 4 (VERSION)
  • react-query 5 (VERSION)
  • react-query v4 (VERSION)
  • react-query v5 (VERSION)
  • react-query@4 (VERSION)
  • react-query@5 (VERSION)
  • tanstack query (VERSION)
  • tanstack/react-query (VERSION)

Context tags (catalog)

caching data fetching infinite scrolling mutations optimistic updates pagination query invalidation query keys react hooks react-query-devtools refetching server state stale time suspense useMutation useQuery

Stored enrichment (catalog DB)

Category
Library
Sub-category
Data Fetching Library
Vendor
TanStack
License
mit
Year introduced
2019
Confidence
0.98
Version strategy
SEPARATE_ENTITY
Version tag
5

Maturity reasoning: Commonly listed in frontend JDs for React apps; strong GitHub adoption and ecosystem use as TanStack Query, with many teams standardizing on it for server-state fetching/caching.

Skill profile (library / DB)

Skill nature
LIBRARY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
7
Sub-category id
1079
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • API Integration and Data Fetching Catalog dimension db id 127

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer, Frontend Developer, Fullstack Developer, React Frontend Developer, Svelte Frontend Developer, Vue Frontend Developer, Web Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
API Integration and Data Fetching
api-integration-and-data-fetching
Existing dimension (library) · Role↔dimension saved
Jest Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Jest id=651 · jest

Aliases — catalog

  • Jest (CANONICAL) primary

Context tags (catalog)

Babel CLI Enzyme JSDOM Jest CLI React Testing Library React testing TypeScript async tests asynchronous testing asynchronous tests babel-jest beforeEach code coverage configuration configuration files coverage coverage reports coverage thresholds describe enzyme expect integration tests it jest-cli jest.config.js jest.fn jest.fn() jest.mock jest.mock() jsdom matchers mock functions mocking setupFiles setupFilesAfterEnv snapshot testing test environment test runner test suites testMatch unit tests watch mode

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Testing Tool
Vendor
Facebook
License
mit
Year introduced
2014
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: Jest appears in many frontend and Node.js job descriptions and remains a standard testing framework in React ecosystems; its GitHub usage and ecosystem integrations are still strong.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
513
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Frontend Testing and E2E Automation Catalog dimension db id 122

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer, Frontend Developer, React Frontend Developer, Svelte Frontend Developer, Vue Frontend Developer, Web Developer

  • Mobile Testing Frameworks Catalog dimension db id 168

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer, Native Mobile Developer, React Native Developer

  • Testing and Integration Validation Catalog dimension db id 217

    Library dimension (catalog)

    Roles linked in library: Fullstack Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Frontend Testing and E2E Automation
frontend-testing-and-e2e-automation
Existing dimension (library) · Role↔dimension saved
Mobile Testing Frameworks
mobile-testing-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Testing and Integration Validation
testing-and-integration-validation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GraphQL Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: GraphQL id=12 · graphql

Aliases — catalog

  • GraphQL (CANONICAL) primary

Context tags (catalog)

API Gateway Apollo DataLoader Fragments GraphQL Server GraphQL server GraphiQL Hasura Introspection Mutations Nexus Queries REST RESTful API Relay Resolvers SDL Schema Subscriptions Type System client-side client-side caching federation fragments introspection middleware mutation mutations persisted queries queries query resolver resolvers schema schema stitching server-side rendering subscription subscriptions type system variables

Stored enrichment (catalog DB)

Category
Language
Sub-category
Query Language
Vendor
Facebook
License
mit
Year introduced
2015
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: GraphQL appears in many modern backend/frontend JDs and is supported by major vendors (Apollo, AWS AppSync, GitHub APIs), indicating broad hiring demand rather than niche use.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
97
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • API Design and Contracts Catalog dimension db id 3

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • API Integration and Data Fetching Catalog dimension db id 127

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer, Frontend Developer, Fullstack Developer, React Frontend Developer, Svelte Frontend Developer, Vue Frontend Developer, Web Developer

  • API Interface and Contract Design Catalog dimension db id 289

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Go Backend Developer, Kotlin Backend Developer, Node.js Backend Developer, PHP Backend Developer, Python Backend Developer, Ruby Backend Developer, Scala Backend Developer

  • External System Integrations Catalog dimension db id 14

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Backend Developer, Drupal Dev, Java Backend Developer, Kotlin Backend Developer, Node.js Backend Developer, PHP Backend Developer, Python Backend Developer, Ruby Backend Developer, Scala Backend Developer

  • Shopify APIs and Webhooks Catalog dimension db id 427

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
API Design and Contracts
api-design-and-contracts
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
API Integration and Data Fetching
api-integration-and-data-fetching
Existing dimension (library) · Role↔dimension saved
API Interface and Contract Design
api-interface-and-contract-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
External System Integrations
external-system-integrations
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Shopify APIs and Webhooks
shopify-apis-and-webhooks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: REST id=11 · rest

Aliases — catalog

  • REST (CANONICAL) primary

Context tags (catalog)

API API design API versioning CRUD DELETE GET HATEOAS HTTP JSON OAuth OAuth2 OpenAPI POST PUT Postman RESTful Swagger URI Webhooks XML authentication client-server content negotiation endpoint endpoints middleware resource resource-oriented serialization stateless status codes versioning web services

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Api Architecture Style
Year introduced
2000
Confidence
0.88
Version strategy
NOT_APPLICABLE

Maturity reasoning: REST is a default API architecture in many job descriptions and is widely supported by major vendors/frameworks; OpenAPI and RESTful endpoints remain standard in hiring pipelines.

Skill profile (library / DB)

Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
2
Sub-category id
2122
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • API Design and Contracts Catalog dimension db id 3

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • API Interface and Contract Design Catalog dimension db id 289

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Go Backend Developer, Kotlin Backend Developer, Node.js Backend Developer, PHP Backend Developer, Python Backend Developer, Ruby Backend Developer, Scala Backend Developer

  • Integration Protocols & Standards Catalog dimension db id 271

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Standards & Protocols Compliance Catalog dimension db id 452

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
API Design and Contracts
api-design-and-contracts
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
API Interface and Contract Design
api-interface-and-contract-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Standards & Protocols Compliance
standards-protocols-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Node.js Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Node.js id=1564 · node-js

Aliases — catalog

  • Node.js (CANONICAL) primary
  • Node 20 LTS (VERSION)
  • Node 20.x (VERSION)
  • Node.js 20 (VERSION)
  • Node.js 20 LTS (VERSION)
  • Node.js 20.x (VERSION)
  • node (VERSION)
  • node 10 (VERSION)
  • node 12 (VERSION)
  • node 14 (VERSION)
  • node 16 (VERSION)
  • node 18 (VERSION)
  • node 20 (VERSION)
  • node v10 (VERSION)
  • node v12 (VERSION)
  • node v14 (VERSION)
  • node v16 (VERSION)
  • node v18 (VERSION)
  • node v20 (VERSION)
  • node.js (VERSION)
  • node.js 10 (VERSION)
  • node.js 12 (VERSION)
  • node.js 14 (VERSION)
  • node.js 16 (VERSION)
  • node.js 18 (VERSION)
  • node.js 20 (VERSION)
  • nodejs (VERSION)
  • nodejs 10 (VERSION)
  • nodejs 12 (VERSION)
  • nodejs 14 (VERSION)
  • nodejs 16 (VERSION)
  • nodejs 18 (VERSION)
  • nodejs 20 (VERSION)

Context tags (catalog)

API Asynchronous Event-driven Express GraphQL JavaScript Jest Koa Microservices Middleware Mocha MongoDB Mongoose NestJS RESTful Socket.io TypeScript npm

Stored enrichment (catalog DB)

Category
Runtime
Sub-category
Javascript Runtime
Vendor
OpenJS Foundation
License
mit
Year introduced
2009
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
20

Maturity reasoning: Node.js appears in high-volume job postings across backend/full-stack roles and is a standard runtime in major cloud/vendor docs and ecosystem tooling, indicating broad hiring-pipeline adoption.

Skill profile (library / DB)

Skill nature
RUNTIME
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
67
Sub-category id
1872
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • JavaScript and TypeScript Catalog dimension db id 114

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer, Frontend Developer, Ionic Developer, Node.js Backend Developer, React Frontend Developer, React Native Developer, Svelte Frontend Developer, Vue Frontend Developer, Web Developer

  • Web Application Frameworks Catalog dimension db id 2

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer, Fullstack Developer, Java Backend Developer, Node.js Backend Developer, PHP Backend Developer, Python Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension saved
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitLab CI Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: GitLab CI id=282 · gitlab-ci

Aliases — catalog

  • GitLab CI (CANONICAL) primary

Context tags (catalog)

.gitlab-ci.yml CI/CD DevOps Docker GitLab Runner Kubernetes YAML artifacts automation build triggers cache deploy deployment environments include integration jobs merge requests monitoring pipelines rules runners stages testing variables version control

Stored enrichment (catalog DB)

Category
Service
Sub-category
Ci Cd Service
Vendor
GitLab Inc.
License
mit
Year introduced
2011
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: Commonly listed in DevOps/CI-CD job descriptions and widely used in GitLab-hosted pipelines; strong market presence alongside Jenkins/GitHub Actions rather than a niche tool.

Skill profile (library / DB)

Skill nature
CLOUD_SERVICE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
11
Sub-category id
178
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • CI/CD for Machine Learning Catalog dimension db id 56

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitHub Actions Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: GitHub Actions id=281 · github-actions

Aliases — catalog

  • GitHub Actions (CANONICAL) primary

Context tags (catalog)

CI/CD GitHub YAML actions actions/checkout actions/setup-node artifacts automation build continuous deployment continuous integration cron deployment environments jobs matrix pull_request push repository reusable workflows runner secrets steps test trigger workflow

Stored enrichment (catalog DB)

Category
Service
Sub-category
Ci Cd Service
Vendor
GitHub
License
apache_2
Year introduced
2018
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: Common CI/CD skill in job postings and GitHub’s default automation platform; widely used for build, test, and deploy workflows across repos.

Skill profile (library / DB)

Skill nature
CLOUD_SERVICE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
11
Sub-category id
178
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • CI/CD for Machine Learning Catalog dimension db id 56

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CircleCI Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: CircleCI id=826 · circleci

Aliases — catalog

  • CircleCI (CANONICAL) primary

Context tags (catalog)

API integration Docker GitHub integration Kubernetes YAML configuration artifact management automated testing build automation cloud infrastructure continuous integration deployment pipelines performance monitoring test orchestration version control webhooks

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Ci Cd Platform
Vendor
CircleCI, Inc.
License
other_open
Year introduced
2011
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: CircleCI appears frequently in DevOps/CI-CD job descriptions and remains a mainstream hosted CI platform alongside GitHub Actions and GitLab CI, indicating broad hiring-market familiarity.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
632
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Objective-C Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Objective-C id=441 · objective-c

Aliases — catalog

  • Objective-C (CANONICAL) primary

Context tags (catalog)

ARC AppKit Cocoa Cocoa Touch Core Data Foundation IBAction IBOutlet Interface Builder NSURLConnection NSURLSession Objective-C runtime Swift UIKit Xcode blocks categories delegates iOS macOS protocols selectors

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Apple
License
other_open
Year introduced
1984
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Objective-C still appears in iOS/macOS legacy maintenance JDs, but most new Apple development listings now favor Swift, indicating a narrow, declining market signal.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Swift and Objective-C Catalog dimension db id 81

    Library dimension (catalog)

    Roles linked in library: iOS Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift and Objective-C
swift-and-objective-c
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Swift id=440 · swift

Aliases — catalog

  • Swift (CANONICAL) primary
  • Swift 2.0 (VERSION)
  • Swift 2.x (VERSION)
  • Swift 3.0 (VERSION)
  • Swift 3.x (VERSION)
  • Swift 4.0 (VERSION)
  • Swift 4.x (VERSION)
  • Swift 5.0 (VERSION)
  • Swift 5.x (VERSION)
  • Swift 6.0 (VERSION)
  • Swift 6.x (VERSION)

Context tags (catalog)

ARC Cocoa Cocoa Touch CocoaPods Combine Core Data Grand Central Dispatch MVVM Objective-C Optionals SPM Swift Package Manager SwiftUI UIKit Xcode async/await asynchronous programming closure closures error handling iOS Development protocol-oriented programming type safety

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Apple
License
apache_2
Year introduced
2014
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Swift is broadly used for iOS/macOS hiring; job postings commonly list it alongside UIKit/SwiftUI, and Apple continues to invest in it as the primary language for new app development.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Swift and Objective-C Catalog dimension db id 81

    Library dimension (catalog)

    Roles linked in library: iOS Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift and Objective-C
swift-and-objective-c
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Java id=1 · java

Aliases — catalog

  • Java (CANONICAL) primary
  • JDK (VERSION)
  • JDK 10 (VERSION)
  • JDK 11 (VERSION)
  • JDK 12 (VERSION)
  • JDK 13 (VERSION)
  • JDK 14 (VERSION)
  • JDK 15 (VERSION)
  • JDK 16 (VERSION)
  • JDK 17 (VERSION)
  • JDK 18 (VERSION)
  • JDK 19 (VERSION)
  • JDK 20 (VERSION)
  • JDK 21 (VERSION)
  • JDK 5 (VERSION)
  • JDK 6 (VERSION)
  • JDK 7 (VERSION)
  • JDK 8 (VERSION)
  • JDK 9 (VERSION)
  • Java 1.0 (VERSION)
  • Java 1.1 (VERSION)
  • Java 1.2 (VERSION)
  • Java 1.3 (VERSION)
  • Java 1.4 (VERSION)
  • Java 1.5 (VERSION)
  • Java 1.6 (VERSION)
  • Java 1.7 (VERSION)
  • Java 1.8 (VERSION)
  • Java 10 (VERSION)
  • Java 11 (VERSION)
  • Java 12 (VERSION)
  • Java 13 (VERSION)
  • Java 14 (VERSION)
  • Java 15 (VERSION)
  • Java 16 (VERSION)
  • Java 17 (VERSION)
  • Java 18 (VERSION)
  • Java 19 (VERSION)
  • Java 20 (VERSION)
  • Java 21 (VERSION)
  • Java 5 (VERSION)
  • Java 6 (VERSION)
  • Java 7 (VERSION)
  • Java 8 (VERSION)
  • Java 9 (VERSION)
  • Java11 (VERSION)
  • Java17 (VERSION)
  • Java21 (VERSION)
  • Java8 (VERSION)
  • OpenJDK 11 (VERSION)
  • OpenJDK 17 (VERSION)
  • OpenJDK 21 (VERSION)
  • OpenJDK 8 (VERSION)
  • java 11 (VERSION)
  • java 17 (VERSION)
  • java 21 (VERSION)
  • java 4 (VERSION)
  • java 5 (VERSION)
  • java 6 (VERSION)
  • java 7 (VERSION)
  • java 8 (VERSION)
  • java lts (VERSION)
  • java-11 (VERSION)
  • java-17 (VERSION)
  • java-21 (VERSION)
  • java-4 (VERSION)
  • java-5 (VERSION)
  • java-6 (VERSION)
  • java-7 (VERSION)
  • java-8 (VERSION)
  • java11 (VERSION)
  • java17 (VERSION)
  • java21 (VERSION)
  • java4 (VERSION)
  • java5 (VERSION)
  • java6 (VERSION)
  • java7 (VERSION)
  • java8 (VERSION)
  • jdk 11 (VERSION)
  • jdk 17 (VERSION)
  • jdk 21 (VERSION)
  • jdk 4 (VERSION)
  • jdk 5 (VERSION)
  • jdk 6 (VERSION)
  • jdk 7 (VERSION)
  • jdk 8 (VERSION)
  • jdk11 (VERSION)
  • jdk17 (VERSION)
  • jdk21 (VERSION)
  • jdk4 (VERSION)
  • jdk5 (VERSION)
  • jdk6 (VERSION)
  • jdk7 (VERSION)
  • jdk8 (VERSION)
  • jvm21 (VERSION)

Context tags (catalog)

APIs Apache Tomcat Concurrency Design patterns Garbage collection GraalVM Gradle Hibernate JDBC JDK JPA JUnit JVM Java 8 Java EE JavaFX Kafka Lambda expressions Maven Microservices Mockito Object-oriented REST RESTful SOAP Servlets Spring Spring Boot Tomcat microservices

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Oracle
License
other_open
Year introduced
1995
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
21

Maturity reasoning: Java is a hiring-pipeline staple with very high JD volume across enterprise backend, Android, and cloud roles; it remains widely supported by major vendors and frameworks like Spring.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Java Language and JVM Catalog dimension db id 279

    Library dimension (catalog)

    Roles linked in library: Java Backend Developer, Kotlin Backend Developer, Scala Backend Developer

  • Kotlin and Java Catalog dimension db id 161

    Library dimension (catalog)

    Roles linked in library: Android Developer

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Pega Programming Languages & DSLs Catalog dimension db id 267

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer, Fullstack Developer

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Java Language and JVM
java-language-and-jvm
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin and Java
kotlin-and-java
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Kotlin id=2 · kotlin

Aliases — catalog

  • Kotlin (CANONICAL) primary
  • kotlin 1.9 (VERSION)
  • kotlin 1.9.0 (VERSION)
  • kotlin 1.9.1 (VERSION)
  • kotlin 1.9.10 (VERSION)
  • kotlin 1.9.x (VERSION)
  • kotlin-1.9 (VERSION)

Context tags (catalog)

Android Anko Coroutines DSL Dagger Data classes Extension functions Flow Gradle Hilt JUnit Jetpack Jetpack Compose Kotlin DSL Kotlin Native Kotlinx Ktor MVI MVVM Mockito Multiplatform Null safety Retrofit Room RxKotlin Sealed classes Spring Type inference

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
JetBrains
License
apache_2
Year introduced
2011
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Kotlin appears in many Android, backend, and multiplatform job postings, and JetBrains reports strong ecosystem growth; it’s a mainstream hiring skill rather than niche.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Java Language and JVM Catalog dimension db id 279

    Library dimension (catalog)

    Roles linked in library: Java Backend Developer, Kotlin Backend Developer, Scala Backend Developer

  • Kotlin and Java Catalog dimension db id 161

    Library dimension (catalog)

    Roles linked in library: Android Developer

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer, Fullstack Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Java Language and JVM
java-language-and-jvm
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin and Java
kotlin-and-java
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Xcode Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Xcode id=479 · xcode

Aliases — catalog

  • Xcode (CANONICAL) primary

Context tags (catalog)

App Store Asset Catalog Build Phases Cocoa Cocoa Touch CocoaPods Code Signing Debugging Git integration Instruments Interface Builder Objective-C Provisioning Profiles Simulator Storyboard Swift Swift Package Manager SwiftUI TestFlight UIKit Version Control XCTest Xcode Server code signing debugging iOS SDK storyboards

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Ide Tool
Vendor
Apple
License
proprietary
Year introduced
2003
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Xcode is the standard IDE in iOS/macOS job postings and Apple’s official toolchain for Swift/Objective-C development; it remains a common hiring requirement for Apple-platform roles.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
359
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Build and Release Tooling Catalog dimension db id 89

    Library dimension (catalog)

    Roles linked in library: Android Developer, Flutter Developer, Hybrid Mobile Developer, iOS Developer

  • Native Mobile Build and Release Tooling Catalog dimension db id 272

    Library dimension (catalog)

    Roles linked in library: Flutter Developer, Native Mobile Developer, React Native Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Build and Release Tooling
build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Native Mobile Build and Release Tooling
native-mobile-build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Gradle Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Gradle id=816 · gradle

Aliases — catalog

  • Gradle (CANONICAL) primary

Context tags (catalog)

Ant CI/CD Gradle Daemon Gradle Enterprise Gradle Plugin Portal Gradle Wrapper Groovy JVM Java Kotlin DSL Maven build automation build cache build lifecycle build scans build script build scripts build.gradle continuous integration dependency management multi-project builds performance optimization plugins task automation task configuration task execution

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Build Tool
Vendor
Gradle Inc.
License
apache_2
Year introduced
2007
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Gradle appears in many Java/Kotlin job descriptions and is a standard build tool in Android and JVM ecosystems; it’s widely used alongside Maven rather than being niche or sunset.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
358
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Build and Dependency Management Catalog dimension db id 286

    Library dimension (catalog)

    Roles linked in library: Java Backend Developer

  • Build and Packaging Tooling Catalog dimension db id 149

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer, Ionic Developer

  • Build and Release Tooling Catalog dimension db id 89

    Library dimension (catalog)

    Roles linked in library: Android Developer, Flutter Developer, Hybrid Mobile Developer, iOS Developer

  • Native Mobile Build and Release Tooling Catalog dimension db id 272

    Library dimension (catalog)

    Roles linked in library: Flutter Developer, Native Mobile Developer, React Native Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Build and Dependency Management
build-and-dependency-management
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Build and Packaging Tooling
build-and-packaging-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Build and Release Tooling
build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Native Mobile Build and Release Tooling
native-mobile-build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Android Studio Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Development Environments
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
SAFe Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Methodologies
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Scrum Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Scrum id=1215 · scrum

Aliases — catalog

  • Scrum (CANONICAL) primary

Context tags (catalog)

Agile Kanban backlog burndown chart cross-functional team daily standup definition of done increment product owner release planning retrospective scrum framework scrum master sprint story points user stories velocity

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Scrum
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Scrum appears in a large share of agile project-management and product-owner job descriptions, and Scrum Alliance/PSM certifications are widely requested in hiring pipelines.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
921
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Code Review Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Code Review id=516 · code-review

Aliases — catalog

  • Code Review (CANONICAL)

Context tags (catalog)

Bitbucket GitHub GitLab PR review approval workflow branch protection code quality diff inline comments linting merge request pair programming pull request review checklist static analysis

Stored enrichment (catalog DB)

Category
SoftSkill
Sub-category
Code Review
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: Code review is a standard hiring-pipeline requirement in engineering JDs and is built into major platforms like GitHub/GitLab pull-request workflows, indicating broad adoption.

Skill profile (library / DB)

Skill nature
PRACTICE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
58
Sub-category id
364
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: CI/CD id=1190 · ci-cd

Aliases — catalog

  • CI/CD (CANONICAL)

Context tags (catalog)

Ansible CircleCI Docker GitLab CI Jenkins Kubernetes Terraform Travis CI automated testing build automation continuous deployment continuous integration deployment pipelines monitoring version control

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Ci Cd Process
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: CI/CD appears in a large share of software engineering JDs and is a standard requirement across DevOps, platform, and backend roles; major vendors like GitHub, GitLab, and AWS all center product roadmaps on CI/CD pipelines.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
900
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • CI/CD for Machine Learning Catalog dimension db id 56

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

All API 3 persistence rows

Same grid as the skill-extractor “Persistence items” table: one row per (skill × dimension) work item.

Skill Tag Dimension Skill↔dim Role↔dim Outcome Notes
React in_db
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
Frontend Frameworks and Libraries
frontend-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
React Component Architecture
react-component-architecture
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
React Native in_db
Cross-Platform Mobile UI Frameworks
cross-platform-mobile-ui-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Native in_db
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
TypeScript in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension saved
TypeScript in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Query in_db
API Integration and Data Fetching
api-integration-and-data-fetching
Existing dimension (library) · Role↔dimension saved
Jest in_db
Frontend Testing and E2E Automation
frontend-testing-and-e2e-automation
Existing dimension (library) · Role↔dimension saved
Jest in_db
Mobile Testing Frameworks
mobile-testing-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Jest in_db
Testing and Integration Validation
testing-and-integration-validation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GraphQL in_db
API Design and Contracts
api-design-and-contracts
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GraphQL in_db
API Integration and Data Fetching
api-integration-and-data-fetching
Existing dimension (library) · Role↔dimension saved
GraphQL in_db
API Interface and Contract Design
api-interface-and-contract-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GraphQL in_db
External System Integrations
external-system-integrations
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GraphQL in_db
Shopify APIs and Webhooks
shopify-apis-and-webhooks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
API Design and Contracts
api-design-and-contracts
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
API Interface and Contract Design
api-interface-and-contract-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
Standards & Protocols Compliance
standards-protocols-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Node.js in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension saved
Node.js in_db
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitLab CI in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitLab CI in_db
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitHub Actions in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitHub Actions in_db
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CircleCI in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Objective-C in_db
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Objective-C in_db
Swift and Objective-C
swift-and-objective-c
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift in_db
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift in_db
Swift and Objective-C
swift-and-objective-c
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Java Language and JVM
java-language-and-jvm
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Kotlin and Java
kotlin-and-java
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Java Language and JVM
java-language-and-jvm
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Kotlin and Java
kotlin-and-java
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Xcode in_db
Build and Release Tooling
build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Xcode in_db
Native Mobile Build and Release Tooling
native-mobile-build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Gradle in_db
Build and Dependency Management
build-and-dependency-management
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Gradle in_db
Build and Packaging Tooling
build-and-packaging-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Gradle in_db
Build and Release Tooling
build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Gradle in_db
Native Mobile Build and Release Tooling
native-mobile-build-and-release-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Scrum in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Code Review in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD in_db
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed Android Studio | type=Development Environments subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed SAFe | type=Methodologies subtype=general nature=PRACTICE lifespan=MULTI_YEAR
nano JD Parser — gpt-4.1-nano click to toggle
RoleLead Developer
CompanyTCS
Experience7 to 10 Years
DomainIT Services & Consulting
Location Hyderabad, India
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": "TCS",
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [
        "ITES",
        "BPO"
      ],
      "domain": "IT Services \u0026 Consulting"
    },
    "secondary": null
  },
  "education": [],
  "experience": {
    "max": 10,
    "min": 7,
    "raw": "7 to 10 Years"
  },
  "job_locations": [
    {
      "aliases": [
        "Hyderabad, AP"
      ],
      "city": "Hyderabad",
      "country": "India",
      "state": null,
      "work_mode": null
    }
  ],
  "role": "Lead Developer",
  "role_aliases": [
    "Software Developer",
    "Lead Software Engineer",
    "Senior Developer"
  ],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 5,
      "heading": "Must-Have",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Thorough production-proven knowledge of",
        "last_5_words": "automated testing suites like Jest"
      },
      "text": "Thorough production-proven knowledge of the React ecosystem.\n\nexperience of React Native and Typescript (be able to demonstrate contribution to a product build with React native) \u00b7 \nExperience with deploying mobile software: \nphased rollouts, feature flagging, CICD approach, build toolchain, App Store Connect, Play Store, \u2026 \u00b7 Familiar with state management eg. React Query \u00b7 \nExperience with automated testing suites like Jest",
      "word_count": 66
    },
    {
      "bullet_count": 6,
      "heading": "Good-to-Have",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Experience with GraphQL and how",
        "last_5_words": "environment is a plus."
      },
      "text": "Experience with GraphQL and how GQL works vs REST api\u0027s \u00b7 Knowledge of Node.js \u00b7 Familiar with one or more CI/CD environments: Gitlab CI, Github Actions, Circle CI, etc \u00b7 Sufficient knowledge of the underlying native platform \u00b7 (Obj-C/Swift/Java/Kotlin/Xcode/Gradle/Android Studio) \u00b7 Working experience in a SAFe environment is a plus.",
      "word_count": 56
    },
    {
      "bullet_count": 4,
      "heading": "Responsibility of / Expectations from the Role",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "1 As part of a scrum",
        "last_5_words": "functional and non-functional requirement."
      },
      "text": "1 As part of a scrum team, you\u2019ll contribute to the continuous development of the product features that are in the care of your team\n2 Design and develop new user stories, create \u0026 review pull requests, document your work, perform research, communicate clearly about your progress\n3 Troubleshoot issues and improve front-end performance\n4 Together with your colleagues, you\u2019ll make sure the product features meets all functional and non-functional requirement.",
      "word_count": 66
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "React"
    },
    {
      "is_primary": true,
      "skill_name": "React Native"
    },
    {
      "is_primary": true,
      "skill_name": "TypeScript"
    },
    {
      "is_primary": false,
      "skill_name": "React Query"
    },
    {
      "is_primary": true,
      "skill_name": "Jest"
    },
    {
      "is_primary": true,
      "skill_name": "GraphQL"
    },
    {
      "is_primary": true,
      "skill_name": "REST"
    },
    {
      "is_primary": true,
      "skill_name": "Node.js"
    },
    {
      "is_primary": false,
      "skill_name": "GitLab CI"
    },
    {
      "is_primary": false,
      "skill_name": "GitHub Actions"
    },
    {
      "is_primary": false,
      "skill_name": "CircleCI"
    },
    {
      "is_primary": false,
      "skill_name": "Objective-C"
    },
    {
      "is_primary": false,
      "skill_name": "Swift"
    },
    {
      "is_primary": false,
      "skill_name": "Java"
    },
    {
      "is_primary": false,
      "skill_name": "Kotlin"
    },
    {
      "is_primary": false,
      "skill_name": "Xcode"
    },
    {
      "is_primary": false,
      "skill_name": "Gradle"
    },
    {
      "is_primary": false,
      "skill_name": "Android Studio"
    },
    {
      "is_primary": false,
      "skill_name": "SAFe"
    },
    {
      "is_primary": false,
      "skill_name": "Scrum"
    },
    {
      "is_primary": false,
      "skill_name": "Code Review"
    },
    {
      "is_primary": true,
      "skill_name": "CI/CD"
    }
  ],
  "jd_role": {
    "display_name": "Lead Developer",
    "rationale": null,
    "role_aliases": [
      "Software Developer",
      "Lead Software Engineer",
      "Senior Developer"
    ],
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": "TCS",
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [
          "ITES",
          "BPO"
        ],
        "domain": "IT Services \u0026 Consulting"
      },
      "secondary": null
    },
    "education": [],
    "experience": {
      "max": 10,
      "min": 7,
      "raw": "7 to 10 Years"
    },
    "job_locations": [
      {
        "aliases": [
          "Hyderabad, AP"
        ],
        "city": "Hyderabad",
        "country": "India",
        "state": null,
        "work_mode": null
      }
    ],
    "role": "Lead Developer",
    "role_aliases": [
      "Software Developer",
      "Lead Software Engineer",
      "Senior Developer"
    ],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 5,
        "heading": "Must-Have",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Thorough production-proven knowledge of",
          "last_5_words": "automated testing suites like Jest"
        },
        "text": "Thorough production-proven knowledge of the React ecosystem.\n\nexperience of React Native and Typescript (be able to demonstrate contribution to a product build with React native) \u00b7 \nExperience with deploying mobile software: \nphased rollouts, feature flagging, CICD approach, build toolchain, App Store Connect, Play Store, \u2026 \u00b7 Familiar with state management eg. React Query \u00b7 \nExperience with automated testing suites like Jest",
        "word_count": 66
      },
      {
        "bullet_count": 6,
        "heading": "Good-to-Have",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Experience with GraphQL and how",
          "last_5_words": "environment is a plus."
        },
        "text": "Experience with GraphQL and how GQL works vs REST api\u0027s \u00b7 Knowledge of Node.js \u00b7 Familiar with one or more CI/CD environments: Gitlab CI, Github Actions, Circle CI, etc \u00b7 Sufficient knowledge of the underlying native platform \u00b7 (Obj-C/Swift/Java/Kotlin/Xcode/Gradle/Android Studio) \u00b7 Working experience in a SAFe environment is a plus.",
        "word_count": 56
      },
      {
        "bullet_count": 4,
        "heading": "Responsibility of / Expectations from the Role",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "1 As part of a scrum",
          "last_5_words": "functional and non-functional requirement."
        },
        "text": "1 As part of a scrum team, you\u2019ll contribute to the continuous development of the product features that are in the care of your team\n2 Design and develop new user stories, create \u0026 review pull requests, document your work, perform research, communicate clearly about your progress\n3 Troubleshoot issues and improve front-end performance\n4 Together with your colleagues, you\u2019ll make sure the product features meets all functional and non-functional requirement.",
        "word_count": 66
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "dfdebd26-442a-4d76-a05f-05d75b628284",
  "stage3_signals": {
    "alias_found": false,
    "alias_match_roles": [],
    "kra_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": [
          {
            "kra_text": "Delivers features through CI/CD pipelines using automated tests, staged rollouts, feature flags, and incremental deployments.",
            "sentence": "phased rollouts, feature flagging, CICD approach, build toolchain, App Store Connect, Play Store, \u2026 \u00b7 Familiar with state management eg.",
            "similarity": 0.6144
          },
          {
            "kra_text": "Works closely with product managers and UX designers to translate requirements and wireframes into working software features through iterative development.",
            "sentence": "4 Together with your colleagues, you\u2019ll make sure the product features meets all functional and non-functional requirement.",
            "similarity": 0.5448
          },
          {
            "kra_text": "Works closely with product managers and UX designers to translate requirements and wireframes into working software features through iterative development.",
            "sentence": "2 Design and develop new user stories, create \u0026 review pull requests, document your work, perform research, communicate clearly about your progress",
            "similarity": 0.5346
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 15,
        "score": 0.5646,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "Supports production releases by diagnosing cross-browser compatibility issues, investigating UI regressions, and resolving frontend performance degradation.",
            "sentence": "3 Troubleshoot issues and improve front-end performance",
            "similarity": 0.5669
          },
          {
            "kra_text": "Builds responsive user interfaces and interactive web components using React, Vue, or Angular with TypeScript, HTML5, and modern CSS for browser-based applications.",
            "sentence": "experience of React Native and Typescript (be able to demonstrate contribution to a product build with React native) \u00b7",
            "similarity": 0.5118
          },
          {
            "kra_text": "Collaborates with UX designers to refine interaction details, animations, responsive breakpoints, and micro-interaction behavior.",
            "sentence": "2 Design and develop new user stories, create \u0026 review pull requests, document your work, perform research, communicate clearly about your progress",
            "similarity": 0.4609
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 7,
        "score": 0.5132,
        "slug": "frontend-engineer",
        "total_count": null
      },
      {
        "display_name": "Angular Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "UI responsiveness and performance",
            "sentence": "3 Troubleshoot issues and improve front-end performance",
            "similarity": 0.5225
          },
          {
            "kra_text": "collaboration with design and QA",
            "sentence": "4 Together with your colleagues, you\u2019ll make sure the product features meets all functional and non-functional requirement.",
            "similarity": 0.4932
          },
          {
            "kra_text": "collaboration with design and QA",
            "sentence": "2 Design and develop new user stories, create \u0026 review pull requests, document your work, perform research, communicate clearly about your progress",
            "similarity": 0.4832
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 90,
        "score": 0.4996,
        "slug": "angular-frontend-developer",
        "total_count": null
      },
      {
        "display_name": "Flutter Developer",
        "kra_matches": [
          {
            "kra_text": "optimize responsiveness and performance",
            "sentence": "3 Troubleshoot issues and improve front-end performance",
            "similarity": 0.5139
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "2 Design and develop new user stories, create \u0026 review pull requests, document your work, perform research, communicate clearly about your progress",
            "similarity": 0.4988
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "1 As part of a scrum team, you\u2019ll contribute to the continuous development of the product features that are in the care of your team",
            "similarity": 0.4821
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 74,
        "score": 0.4982,
        "slug": "flutter-developer",
        "total_count": null
      },
      {
        "display_name": "Hybrid Mobile Developer",
        "kra_matches": [
          {
            "kra_text": "Manages build configurations, code signing certificates, and app store release submissions for both Google Play and Apple App Store.",
            "sentence": "phased rollouts, feature flagging, CICD approach, build toolchain, App Store Connect, Play Store, \u2026 \u00b7 Familiar with state management eg.",
            "similarity": 0.5668
          },
          {
            "kra_text": "Accesses native device capabilities including camera, location services, Bluetooth, and biometric authentication through React Native or Flutter plugins.",
            "sentence": "experience of React Native and Typescript (be able to demonstrate contribution to a product build with React native) \u00b7",
            "similarity": 0.4763
          },
          {
            "kra_text": "Builds mobile navigation flows, tab bar routing, modal sheets, and deep link handling using React Navigation or Flutter Navigator.",
            "sentence": "Thorough production-proven knowledge of the React ecosystem.",
            "similarity": 0.4032
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 11,
        "score": 0.4821,
        "slug": "hybrid-mobile-developer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": 7,
        "matched_skills": [
          "GraphQL",
          "Jest",
          "Node.js",
          "REST",
          "React",
          "React Native",
          "TypeScript"
        ],
        "role_id": 15,
        "score": 0.875,
        "slug": "full-stack-engineer",
        "total_count": 8
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": null,
        "matched_count": 6,
        "matched_skills": [
          "GraphQL",
          "Jest",
          "Node.js",
          "React",
          "React Native",
          "TypeScript"
        ],
        "role_id": 7,
        "score": 0.75,
        "slug": "frontend-engineer",
        "total_count": 8
      },
      {
        "display_name": "Web Developer",
        "kra_matches": null,
        "matched_count": 6,
        "matched_skills": [
          "GraphQL",
          "Jest",
          "Node.js",
          "React",
          "React Native",
          "TypeScript"
        ],
        "role_id": 25,
        "score": 0.75,
        "slug": "web-developer",
        "total_count": 8
      },
      {
        "display_name": "React Frontend Developer",
        "kra_matches": null,
        "matched_count": 5,
        "matched_skills": [
          "GraphQL",
          "Jest",
          "Node.js",
          "React",
          "TypeScript"
        ],
        "role_id": 89,
        "score": 0.625,
        "slug": "react-frontend-developer",
        "total_count": 8
      },
      {
        "display_name": "Hybrid Mobile Developer",
        "kra_matches": null,
        "matched_count": 4,
        "matched_skills": [
          "Jest",
          "React",
          "React Native",
          "TypeScript"
        ],
        "role_id": 11,
        "score": 0.5,
        "slug": "hybrid-mobile-developer",
        "total_count": 8
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "DOMAIN",
    "chosen_role": {
      "display_name": "Frontend Developer",
      "kra_matches": null,
      "matched_count": null,
      "matched_skills": null,
      "role_id": 7,
      "score": 0.95,
      "slug": "frontend-engineer",
      "total_count": null
    },
    "confidence": 0.95,
    "is_new_role": false,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "matched_dimensions": [
      "React frontend development",
      "Mobile app development",
      "CI/CD and release engineering",
      "Frontend performance optimization",
      "Automated testing",
      "Scrum-based product development"
    ],
    "matched_kras": [
      "Contribute to the continuous development of product features",
      "Design and develop new user stories",
      "Create and review pull requests",
      "Document your work",
      "Troubleshoot issues and improve front-end performance",
      "Ensure product features meet functional and non-functional requirements"
    ],
    "matched_skills": [
      "React",
      "React Native",
      "TypeScript",
      "React Query",
      "Jest",
      "GraphQL",
      "REST API",
      "Node.js",
      "Gitlab CI",
      "Github Actions",
      "Circle CI",
      "App Store Connect",
      "Play Store",
      "Obj-C",
      "Swift",
      "Java",
      "Kotlin",
      "Xcode",
      "Gradle",
      "Android Studio"
    ],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "Domain=Software Engineering \u2192 sub-role react-frontend-developer; The JD is centered on React/TypeScript frontend development, with mobile and CI/CD concerns as supporting responsibilities.",
    "sub_role": {
      "confidence": 0.99,
      "display_name": "React Frontend Developer",
      "reasoning": "The JD is explicitly centered on the React ecosystem, React Native, TypeScript, React Query, GraphQL, and related React tooling, so React Frontend Developer is the clear match.",
      "role_id": 89,
      "slug": "react-frontend-developer"
    }
  },
  "stage5_updates": {
    "centroid_n_after": 158,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": null,
    "new_skills_attached": [
      {
        "is_primary": false,
        "queue_id": 9002,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "Android Studio",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 9003,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "SAFe",
        "status": "pending"
      }
    ],
    "queue_entry_id": null,
    "v3_pipeline_triggered": false,
    "v3_role_slug": null,
    "v3_run_id": null
  }
}
API 2 — extract-details
{
  "alias_matches": [
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1047,
      "existing_alias_text": "React",
      "input_term": "React",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "React",
        "id": 610,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1657,
      "existing_alias_text": "React Native",
      "input_term": "React Native",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "React Native",
        "id": 1040,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react-native",
        "sub_category_id": 2146,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 914,
      "existing_alias_text": "TypeScript",
      "input_term": "TypeScript",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "TypeScript",
        "id": 524,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2259,
      "existing_alias_text": "React Query",
      "input_term": "React Query",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "React Query",
        "id": 1411,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "react-query",
        "sub_category_id": 1079,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1156,
      "existing_alias_text": "Jest",
      "input_term": "Jest",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Jest",
        "id": 651,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "jest",
        "sub_category_id": 513,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 107,
      "existing_alias_text": "GraphQL",
      "input_term": "GraphQL",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "GraphQL",
        "id": 12,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "graphql",
        "sub_category_id": 97,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 106,
      "existing_alias_text": "REST",
      "input_term": "REST",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "REST",
        "id": 11,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rest",
        "sub_category_id": 2122,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2500,
      "existing_alias_text": "Node.js",
      "input_term": "Node.js",
      "matched_canonical": {
        "category_id": 67,
        "display_name": "Node.js",
        "id": 1564,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "RUNTIME",
        "slug": "node-js",
        "sub_category_id": 1872,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 543,
      "existing_alias_text": "GitLab CI",
      "input_term": "GitLab CI",
      "matched_canonical": {
        "category_id": 11,
        "display_name": "GitLab CI",
        "id": 282,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "gitlab-ci",
        "sub_category_id": 178,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 542,
      "existing_alias_text": "GitHub Actions",
      "input_term": "GitHub Actions",
      "matched_canonical": {
        "category_id": 11,
        "display_name": "GitHub Actions",
        "id": 281,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "github-actions",
        "sub_category_id": 178,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1371,
      "existing_alias_text": "CircleCI",
      "input_term": "CircleCI",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "CircleCI",
        "id": 826,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "circleci",
        "sub_category_id": 632,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 767,
      "existing_alias_text": "Objective-C",
      "input_term": "Objective-C",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Objective-C",
        "id": 441,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "objective-c",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 756,
      "existing_alias_text": "Swift",
      "input_term": "Swift",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Swift",
        "id": 440,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "swift",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1,
      "existing_alias_text": "Java",
      "input_term": "Java",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Java",
        "id": 1,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "java",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 24,
      "existing_alias_text": "Kotlin",
      "input_term": "Kotlin",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Kotlin",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "kotlin",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 805,
      "existing_alias_text": "Xcode",
      "input_term": "Xcode",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Xcode",
        "id": 479,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "xcode",
        "sub_category_id": 359,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1361,
      "existing_alias_text": "Gradle",
      "input_term": "Gradle",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Gradle",
        "id": 816,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "gradle",
        "sub_category_id": 358,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1851,
      "existing_alias_text": "Scrum",
      "input_term": "Scrum",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Scrum",
        "id": 1215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "scrum",
        "sub_category_id": 921,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 864,
      "existing_alias_text": "Code Review",
      "input_term": "Code Review",
      "matched_canonical": {
        "category_id": 58,
        "display_name": "Code Review",
        "id": 516,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PRACTICE",
        "slug": "code-review",
        "sub_category_id": 364,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1826,
      "existing_alias_text": "CI/CD",
      "input_term": "CI/CD",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Sitecore Dev",
      "id": 233,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "sitecore-dev",
      "source": "db"
    },
    {
      "display_name": "Shopify Dev",
      "id": 230,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "shopify-dev",
      "source": "db"
    },
    {
      "display_name": "WordPress Dev",
      "id": 227,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "wordpress-dev",
      "source": "db"
    },
    {
      "display_name": "React Frontend Developer",
      "id": 89,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Frontend Developer",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 435,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "fullstack-developer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 15,
      "rationale": null,
      "role_archetype": null,
      "slug": "full-stack-engineer",
      "source": "db"
    },
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "Ionic Developer",
      "id": 434,
      "rationale": null,
      "role_archetype": null,
      "slug": "ionic-developer",
      "source": "db"
    },
    {
      "display_name": "Web Developer",
      "id": 25,
      "rationale": null,
      "role_archetype": null,
      "slug": "web-developer",
      "source": "db"
    },
    {
      "display_name": "React Native Developer",
      "id": 73,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-native-developer",
      "source": "db"
    },
    {
      "display_name": "Angular Frontend Developer",
      "id": 90,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "angular-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Node.js Backend Developer",
      "id": 82,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "node-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Svelte Frontend Developer",
      "id": 92,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "svelte-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Vue Frontend Developer",
      "id": 91,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "vue-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Backend Developer",
      "id": 1,
      "rationale": null,
      "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
      "slug": "backend-engineer",
      "source": "db"
    },
    {
      "display_name": "AR/VR Engineer",
      "id": 8,
      "rationale": null,
      "role_archetype": null,
      "slug": "ar-vr-engineer",
      "source": "db"
    },
    {
      "display_name": "Native Mobile Developer",
      "id": 75,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "native-mobile-developer",
      "source": "db"
    },
    {
      "display_name": ".NET Backend Developer",
      "id": 83,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "dotnet-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Go Backend Developer",
      "id": 81,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "go-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Kotlin Backend Developer",
      "id": 84,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "kotlin-server-backend-developer",
      "source": "db"
    },
    {
      "display_name": "PHP Backend Developer",
      "id": 86,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "php-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Python Backend Developer",
      "id": 80,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "python-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Ruby Backend Developer",
      "id": 85,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "ruby-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Scala Backend Developer",
      "id": 87,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "scala-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Drupal Dev",
      "id": 228,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "drupal-dev",
      "source": "db"
    },
    {
      "display_name": "Java Backend Developer",
      "id": 79,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "java-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Pega Developer",
      "id": 24,
      "rationale": null,
      "role_archetype": null,
      "slug": "pega-developer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "ML Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-engineer",
      "source": "db"
    },
    {
      "display_name": "iOS Developer",
      "id": 6,
      "rationale": null,
      "role_archetype": null,
      "slug": "ios-engineer",
      "source": "db"
    },
    {
      "display_name": "Android Developer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "android-engineer",
      "source": "db"
    },
    {
      "display_name": "Data Engineer",
      "id": 2,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-engineer",
      "source": "db"
    },
    {
      "display_name": "Flutter Developer",
      "id": 74,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "flutter-developer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Frontend Developer",
    "id": 7,
    "rationale": "Domain=Software Engineering \u2192 sub-role react-frontend-developer; The JD is centered on React/TypeScript frontend development, with mobile and CI/CD concerns as supporting responsibilities.",
    "role_archetype": null,
    "slug": "frontend-engineer",
    "source": "db"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Application Frameworks \u0026 Libraries",
        "id": 451,
        "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
        "slug": "application-frameworks-libraries",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Frameworks and Libraries",
        "id": 434,
        "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
        "slug": "frontend-frameworks-and-libraries",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "JavaScript for WordPress",
        "id": 329,
        "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
        "slug": "javascript-for-wordpress",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "WordPress Dev",
          "id": 227,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "wordpress-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Component Architecture",
        "id": 302,
        "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
        "slug": "react-component-architecture",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform Mobile UI Frameworks",
        "id": 319,
        "rationale": "Frameworks, rendering models, and component libraries used to build shared mobile screens, layouts, and interactive experiences across platforms. This includes React Native and related tooling such as React Native CLI and Expo, as well as cross-platform UI libraries and interaction patterns like React Native Paper, NativeBase, gesture handlers, and animated components; it also covers comparable hybrid mobile UI frameworks such as Flutter. Excludes browser-only frontend frameworks and native platform UI toolkits such as SwiftUI, UIKit, Jetpack Compose, and Android Views.",
        "slug": "cross-platform-mobile-ui-frameworks",
        "source": "db"
      },
      "input_skill": "React Native",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "React Native",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "JavaScript and TypeScript",
        "id": 114,
        "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
        "slug": "javascript-and-typescript",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Integration and Data Fetching",
        "id": 127,
        "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
        "slug": "api-integration-and-data-fetching",
        "source": "db"
      },
      "input_skill": "React Query",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Testing and E2E Automation",
        "id": 122,
        "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
        "slug": "frontend-testing-and-e2e-automation",
        "source": "db"
      },
      "input_skill": "Jest",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Mobile Testing Frameworks",
        "id": 168,
        "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
        "slug": "mobile-testing-frameworks",
        "source": "db"
      },
      "input_skill": "Jest",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Testing and Integration Validation",
        "id": 217,
        "rationale": "Automated checks used to verify feature behavior across client, server, and data boundaries. Full stack engineers rely on this to catch regressions in end-to-end flows and integration points.",
        "slug": "testing-and-integration-validation",
        "source": "db"
      },
      "input_skill": "Jest",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Design and Contracts",
        "id": 3,
        "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
        "slug": "api-design-and-contracts",
        "source": "db"
      },
      "input_skill": "GraphQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Integration and Data Fetching",
        "id": 127,
        "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
        "slug": "api-integration-and-data-fetching",
        "source": "db"
      },
      "input_skill": "GraphQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Interface and Contract Design",
        "id": 289,
        "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
        "slug": "api-interface-and-contract-design",
        "source": "db"
      },
      "input_skill": "GraphQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "External System Integrations",
        "id": 14,
        "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
        "slug": "external-system-integrations",
        "source": "db"
      },
      "input_skill": "GraphQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Shopify APIs and Webhooks",
        "id": 427,
        "rationale": "Integration work that connects storefronts and apps to external business systems through Shopify interfaces. This cluster is central because Shopify Dev often wires store behavior to inventory, ERP, CRM, and fulfillment systems.",
        "slug": "shopify-apis-and-webhooks",
        "source": "db"
      },
      "input_skill": "GraphQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Design and Contracts",
        "id": 3,
        "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
        "slug": "api-design-and-contracts",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Interface and Contract Design",
        "id": 289,
        "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
        "slug": "api-interface-and-contract-design",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Integration Protocols \u0026 Standards",
        "id": 271,
        "rationale": "Standards and protocols for integrating Pega applications.",
        "slug": "integration-protocols-standards",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Standards \u0026 Protocols Compliance",
        "id": 452,
        "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
        "slug": "standards-protocols-compliance",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "JavaScript and TypeScript",
        "id": 114,
        "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
        "slug": "javascript-and-typescript",
        "source": "db"
      },
      "input_skill": "Node.js",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web Application Frameworks",
        "id": 2,
        "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
        "slug": "web-application-frameworks",
        "source": "db"
      },
      "input_skill": "Node.js",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "GitLab CI",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "GitLab CI",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "GitHub Actions",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "GitHub Actions",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "CircleCI",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Objective-C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Swift and Objective-C",
        "id": 81,
        "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
        "slug": "swift-and-objective-c",
        "source": "db"
      },
      "input_skill": "Objective-C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Swift",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Swift and Objective-C",
        "id": 81,
        "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
        "slug": "swift-and-objective-c",
        "source": "db"
      },
      "input_skill": "Swift",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Java Language and JVM",
        "id": 279,
        "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
        "slug": "java-language-and-jvm",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kotlin and Java",
        "id": 161,
        "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
        "slug": "kotlin-and-java",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Pega Programming Languages \u0026 DSLs",
        "id": 267,
        "rationale": "Programming languages and domain-specific languages used in Pega development.",
        "slug": "pega-programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 21,
        "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Java Language and JVM",
        "id": 279,
        "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
        "slug": "java-language-and-jvm",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kotlin and Java",
        "id": 161,
        "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
        "slug": "kotlin-and-java",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Build and Release Tooling",
        "id": 89,
        "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
        "slug": "build-and-release-tooling",
        "source": "db"
      },
      "input_skill": "Xcode",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Build and Release Tooling",
        "id": 272,
        "rationale": "Tooling used to compile, sign, package, version, and automate release-ready builds for native mobile apps across iOS and Android. This cluster includes platform-specific build systems and release automation used to produce reproducible app artifacts and prepare internal or public release candidates.",
        "slug": "native-mobile-build-and-release-tooling",
        "source": "db"
      },
      "input_skill": "Xcode",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Build and Dependency Management",
        "id": 286,
        "rationale": "Project build, packaging, and dependency resolution skills used to compile and assemble Java services. This cluster matters because backend delivery depends on reproducible builds and controlled library versions.",
        "slug": "build-and-dependency-management",
        "source": "db"
      },
      "input_skill": "Gradle",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Build and Packaging Tooling",
        "id": 149,
        "rationale": "Tooling used to compile, package, and prepare Ionic apps for development and release. This cluster is coherent because Ionic developers often manage web assets, native wrappers, and environment-specific build outputs.",
        "slug": "build-and-packaging-tooling",
        "source": "db"
      },
      "input_skill": "Gradle",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Build and Release Tooling",
        "id": 89,
        "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
        "slug": "build-and-release-tooling",
        "source": "db"
      },
      "input_skill": "Gradle",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Build and Release Tooling",
        "id": 272,
        "rationale": "Tooling used to compile, sign, package, version, and automate release-ready builds for native mobile apps across iOS and Android. This cluster includes platform-specific build systems and release automation used to produce reproducible app artifacts and prepare internal or public release candidates.",
        "slug": "native-mobile-build-and-release-tooling",
        "source": "db"
      },
      "input_skill": "Gradle",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Scrum",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Code Review",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "React",
    "React Native",
    "TypeScript",
    "React Query",
    "Jest",
    "GraphQL",
    "REST",
    "Node.js",
    "GitLab CI",
    "GitHub Actions",
    "CircleCI",
    "Objective-C",
    "Swift",
    "Java",
    "Kotlin",
    "Xcode",
    "Gradle",
    "Android Studio",
    "SAFe",
    "Scrum",
    "Code Review",
    "CI/CD"
  ],
  "input_llm_skills": [
    "React",
    "React Native",
    "TypeScript",
    "React Query",
    "Jest",
    "GraphQL",
    "REST",
    "Node.js",
    "GitLab CI",
    "GitHub Actions",
    "CircleCI",
    "Objective-C",
    "Swift",
    "Java",
    "Kotlin",
    "Xcode",
    "Gradle",
    "Android Studio",
    "SAFe",
    "Scrum",
    "Code Review",
    "CI/CD"
  ],
  "new_aliases_persisted": 0,
  "run_id": "dfdebd26-442a-4d76-a05f-05d75b628284",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "React",
          "alias_type": "CANONICAL",
          "id": 1047,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 0.13",
          "alias_type": "VERSION",
          "id": 1052,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 0.14",
          "alias_type": "VERSION",
          "id": 1053,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 15",
          "alias_type": "VERSION",
          "id": 1048,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 15.x",
          "alias_type": "VERSION",
          "id": 1054,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 16",
          "alias_type": "VERSION",
          "id": 1049,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 16.x",
          "alias_type": "VERSION",
          "id": 1055,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 17",
          "alias_type": "VERSION",
          "id": 1050,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 17.x",
          "alias_type": "VERSION",
          "id": 1056,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 18",
          "alias_type": "VERSION",
          "id": 1051,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 18.x",
          "alias_type": "VERSION",
          "id": 1057,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 19",
          "alias_type": "VERSION",
          "id": 2068,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v15",
          "alias_type": "VERSION",
          "id": 3185,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v16",
          "alias_type": "VERSION",
          "id": 3186,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v17",
          "alias_type": "VERSION",
          "id": 3187,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v18",
          "alias_type": "VERSION",
          "id": 3188,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ReactJS 18",
          "alias_type": "VERSION",
          "id": 2074,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 15",
          "alias_type": "VERSION",
          "id": 2069,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 16",
          "alias_type": "VERSION",
          "id": 2070,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 17",
          "alias_type": "VERSION",
          "id": 2071,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 18",
          "alias_type": "VERSION",
          "id": 2072,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 19",
          "alias_type": "VERSION",
          "id": 2073,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react15",
          "alias_type": "VERSION",
          "id": 3177,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react16",
          "alias_type": "VERSION",
          "id": 3178,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react17",
          "alias_type": "VERSION",
          "id": 3179,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react18",
          "alias_type": "VERSION",
          "id": 3180,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "reactjs 18",
          "alias_type": "VERSION",
          "id": 2075,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "React",
        "id": 610,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Application Frameworks \u0026 Libraries",
            "id": 451,
            "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
            "slug": "application-frameworks-libraries",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Frameworks and Libraries",
            "id": 434,
            "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
            "slug": "frontend-frameworks-and-libraries",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript for WordPress",
            "id": 329,
            "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
            "slug": "javascript-for-wordpress",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "WordPress Dev",
              "id": 227,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "wordpress-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Component Architecture",
            "id": 302,
            "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
            "slug": "react-component-architecture",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "React Native",
          "alias_type": "CANONICAL",
          "id": 1657,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "React Native",
        "id": 1040,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react-native",
        "sub_category_id": 2146,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform Mobile UI Frameworks",
            "id": 319,
            "rationale": "Frameworks, rendering models, and component libraries used to build shared mobile screens, layouts, and interactive experiences across platforms. This includes React Native and related tooling such as React Native CLI and Expo, as well as cross-platform UI libraries and interaction patterns like React Native Paper, NativeBase, gesture handlers, and animated components; it also covers comparable hybrid mobile UI frameworks such as Flutter. Excludes browser-only frontend frameworks and native platform UI toolkits such as SwiftUI, UIKit, Jetpack Compose, and Android Views.",
            "slug": "cross-platform-mobile-ui-frameworks",
            "source": "db"
          },
          "input_skill": "React Native",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "React Native",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React Native",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "TypeScript",
          "alias_type": "CANONICAL",
          "id": 914,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5",
          "alias_type": "VERSION",
          "id": 3157,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5.x",
          "alias_type": "VERSION",
          "id": 3159,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ts",
          "alias_type": "VERSION",
          "id": 1647,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ts5",
          "alias_type": "VERSION",
          "id": 1648,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript 5",
          "alias_type": "VERSION",
          "id": 1649,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript 5.x",
          "alias_type": "VERSION",
          "id": 1650,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript5",
          "alias_type": "VERSION",
          "id": 2179,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "TypeScript",
        "id": 524,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript and TypeScript",
            "id": 114,
            "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
            "slug": "javascript-and-typescript",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Sitecore Development Languages",
            "id": 438,
            "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
            "slug": "sitecore-development-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "TypeScript",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "React Query",
          "alias_type": "CANONICAL",
          "id": 2259,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react query 4",
          "alias_type": "VERSION",
          "id": 2260,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react query 5",
          "alias_type": "VERSION",
          "id": 2261,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react-query 4",
          "alias_type": "VERSION",
          "id": 2262,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react-query 5",
          "alias_type": "VERSION",
          "id": 2263,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react-query v4",
          "alias_type": "VERSION",
          "id": 2266,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react-query v5",
          "alias_type": "VERSION",
          "id": 2267,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react-query@4",
          "alias_type": "VERSION",
          "id": 2264,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react-query@5",
          "alias_type": "VERSION",
          "id": 2265,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tanstack query",
          "alias_type": "VERSION",
          "id": 2268,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tanstack/react-query",
          "alias_type": "VERSION",
          "id": 2269,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "React Query",
        "id": 1411,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "react-query",
        "sub_category_id": 1079,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Integration and Data Fetching",
            "id": 127,
            "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
            "slug": "api-integration-and-data-fetching",
            "source": "db"
          },
          "input_skill": "React Query",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React Query",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Jest",
          "alias_type": "CANONICAL",
          "id": 1156,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Jest",
        "id": 651,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "jest",
        "sub_category_id": 513,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Testing and E2E Automation",
            "id": 122,
            "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
            "slug": "frontend-testing-and-e2e-automation",
            "source": "db"
          },
          "input_skill": "Jest",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Mobile Testing Frameworks",
            "id": 168,
            "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
            "slug": "mobile-testing-frameworks",
            "source": "db"
          },
          "input_skill": "Jest",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Testing and Integration Validation",
            "id": 217,
            "rationale": "Automated checks used to verify feature behavior across client, server, and data boundaries. Full stack engineers rely on this to catch regressions in end-to-end flows and integration points.",
            "slug": "testing-and-integration-validation",
            "source": "db"
          },
          "input_skill": "Jest",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Jest",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "GraphQL",
          "alias_type": "CANONICAL",
          "id": 107,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "GraphQL",
        "id": 12,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "graphql",
        "sub_category_id": 97,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Design and Contracts",
            "id": 3,
            "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
            "slug": "api-design-and-contracts",
            "source": "db"
          },
          "input_skill": "GraphQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Integration and Data Fetching",
            "id": 127,
            "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
            "slug": "api-integration-and-data-fetching",
            "source": "db"
          },
          "input_skill": "GraphQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Interface and Contract Design",
            "id": 289,
            "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
            "slug": "api-interface-and-contract-design",
            "source": "db"
          },
          "input_skill": "GraphQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "External System Integrations",
            "id": 14,
            "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
            "slug": "external-system-integrations",
            "source": "db"
          },
          "input_skill": "GraphQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Shopify APIs and Webhooks",
            "id": 427,
            "rationale": "Integration work that connects storefronts and apps to external business systems through Shopify interfaces. This cluster is central because Shopify Dev often wires store behavior to inventory, ERP, CRM, and fulfillment systems.",
            "slug": "shopify-apis-and-webhooks",
            "source": "db"
          },
          "input_skill": "GraphQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "GraphQL",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "REST",
          "alias_type": "CANONICAL",
          "id": 106,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "REST",
        "id": 11,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rest",
        "sub_category_id": 2122,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Design and Contracts",
            "id": 3,
            "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
            "slug": "api-design-and-contracts",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Interface and Contract Design",
            "id": 289,
            "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
            "slug": "api-interface-and-contract-design",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Integration Protocols \u0026 Standards",
            "id": 271,
            "rationale": "Standards and protocols for integrating Pega applications.",
            "slug": "integration-protocols-standards",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Standards \u0026 Protocols Compliance",
            "id": 452,
            "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
            "slug": "standards-protocols-compliance",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "REST",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Node.js",
          "alias_type": "CANONICAL",
          "id": 2500,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node 20 LTS",
          "alias_type": "VERSION",
          "id": 2508,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node 20.x",
          "alias_type": "VERSION",
          "id": 2506,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node.js 20",
          "alias_type": "VERSION",
          "id": 2505,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node.js 20 LTS",
          "alias_type": "VERSION",
          "id": 2509,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node.js 20.x",
          "alias_type": "VERSION",
          "id": 2507,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node",
          "alias_type": "VERSION",
          "id": 2501,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 10",
          "alias_type": "VERSION",
          "id": 3786,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 12",
          "alias_type": "VERSION",
          "id": 3787,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 14",
          "alias_type": "VERSION",
          "id": 3788,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 16",
          "alias_type": "VERSION",
          "id": 3789,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 18",
          "alias_type": "VERSION",
          "id": 3790,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 20",
          "alias_type": "VERSION",
          "id": 2503,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v10",
          "alias_type": "VERSION",
          "id": 3793,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v12",
          "alias_type": "VERSION",
          "id": 3794,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v14",
          "alias_type": "VERSION",
          "id": 3795,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v16",
          "alias_type": "VERSION",
          "id": 3796,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v18",
          "alias_type": "VERSION",
          "id": 3797,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v20",
          "alias_type": "VERSION",
          "id": 3798,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js",
          "alias_type": "VERSION",
          "id": 3792,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 10",
          "alias_type": "VERSION",
          "id": 3805,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 12",
          "alias_type": "VERSION",
          "id": 3806,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 14",
          "alias_type": "VERSION",
          "id": 3807,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 16",
          "alias_type": "VERSION",
          "id": 3808,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 18",
          "alias_type": "VERSION",
          "id": 3809,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 20",
          "alias_type": "VERSION",
          "id": 3810,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs",
          "alias_type": "VERSION",
          "id": 2502,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 10",
          "alias_type": "VERSION",
          "id": 3799,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 12",
          "alias_type": "VERSION",
          "id": 3800,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 14",
          "alias_type": "VERSION",
          "id": 3801,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 16",
          "alias_type": "VERSION",
          "id": 3802,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 18",
          "alias_type": "VERSION",
          "id": 3803,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 20",
          "alias_type": "VERSION",
          "id": 2504,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 67,
        "display_name": "Node.js",
        "id": 1564,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "RUNTIME",
        "slug": "node-js",
        "sub_category_id": 1872,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript and TypeScript",
            "id": 114,
            "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
            "slug": "javascript-and-typescript",
            "source": "db"
          },
          "input_skill": "Node.js",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web Application Frameworks",
            "id": 2,
            "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
            "slug": "web-application-frameworks",
            "source": "db"
          },
          "input_skill": "Node.js",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Node.js",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "GitLab CI",
          "alias_type": "CANONICAL",
          "id": 543,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 11,
        "display_name": "GitLab CI",
        "id": 282,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "gitlab-ci",
        "sub_category_id": 178,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "GitLab CI",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "GitLab CI",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "GitLab CI",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "GitHub Actions",
          "alias_type": "CANONICAL",
          "id": 542,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 11,
        "display_name": "GitHub Actions",
        "id": 281,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "github-actions",
        "sub_category_id": 178,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "GitHub Actions",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "GitHub Actions",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "GitHub Actions",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "CircleCI",
          "alias_type": "CANONICAL",
          "id": 1371,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "CircleCI",
        "id": 826,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "circleci",
        "sub_category_id": 632,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "CircleCI",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "CircleCI",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Objective-C",
          "alias_type": "CANONICAL",
          "id": 767,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Objective-C",
        "id": 441,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "objective-c",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Objective-C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Swift and Objective-C",
            "id": 81,
            "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
            "slug": "swift-and-objective-c",
            "source": "db"
          },
          "input_skill": "Objective-C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Objective-C",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Swift",
          "alias_type": "CANONICAL",
          "id": 756,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 2.0",
          "alias_type": "VERSION",
          "id": 757,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 2.x",
          "alias_type": "VERSION",
          "id": 758,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 3.0",
          "alias_type": "VERSION",
          "id": 759,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 3.x",
          "alias_type": "VERSION",
          "id": 760,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 4.0",
          "alias_type": "VERSION",
          "id": 761,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 4.x",
          "alias_type": "VERSION",
          "id": 762,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 5.0",
          "alias_type": "VERSION",
          "id": 763,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 5.x",
          "alias_type": "VERSION",
          "id": 764,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 6.0",
          "alias_type": "VERSION",
          "id": 765,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 6.x",
          "alias_type": "VERSION",
          "id": 766,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Swift",
        "id": 440,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "swift",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Swift",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Swift and Objective-C",
            "id": 81,
            "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
            "slug": "swift-and-objective-c",
            "source": "db"
          },
          "input_skill": "Swift",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Swift",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Java",
          "alias_type": "CANONICAL",
          "id": 1,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK",
          "alias_type": "VERSION",
          "id": 2968,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 10",
          "alias_type": "VERSION",
          "id": 2194,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 11",
          "alias_type": "VERSION",
          "id": 4,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 12",
          "alias_type": "VERSION",
          "id": 2196,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 13",
          "alias_type": "VERSION",
          "id": 2197,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 14",
          "alias_type": "VERSION",
          "id": 2198,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 15",
          "alias_type": "VERSION",
          "id": 2199,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 16",
          "alias_type": "VERSION",
          "id": 2200,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 17",
          "alias_type": "VERSION",
          "id": 5,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 18",
          "alias_type": "VERSION",
          "id": 2202,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 19",
          "alias_type": "VERSION",
          "id": 2203,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 20",
          "alias_type": "VERSION",
          "id": 2204,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 21",
          "alias_type": "VERSION",
          "id": 6,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 5",
          "alias_type": "VERSION",
          "id": 2189,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 6",
          "alias_type": "VERSION",
          "id": 2190,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 7",
          "alias_type": "VERSION",
          "id": 2191,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 8",
          "alias_type": "VERSION",
          "id": 3,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 9",
          "alias_type": "VERSION",
          "id": 2193,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.0",
          "alias_type": "VERSION",
          "id": 11,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.1",
          "alias_type": "VERSION",
          "id": 12,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.2",
          "alias_type": "VERSION",
          "id": 13,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.3",
          "alias_type": "VERSION",
          "id": 14,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.4",
          "alias_type": "VERSION",
          "id": 15,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.5",
          "alias_type": "VERSION",
          "id": 16,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.6",
          "alias_type": "VERSION",
          "id": 17,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.7",
          "alias_type": "VERSION",
          "id": 18,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.8",
          "alias_type": "VERSION",
          "id": 19,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 10",
          "alias_type": "VERSION",
          "id": 2211,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 11",
          "alias_type": "VERSION",
          "id": 8,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 12",
          "alias_type": "VERSION",
          "id": 2213,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 13",
          "alias_type": "VERSION",
          "id": 2214,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 14",
          "alias_type": "VERSION",
          "id": 2215,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 15",
          "alias_type": "VERSION",
          "id": 2216,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 16",
          "alias_type": "VERSION",
          "id": 2217,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 17",
          "alias_type": "VERSION",
          "id": 9,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 18",
          "alias_type": "VERSION",
          "id": 2219,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 19",
          "alias_type": "VERSION",
          "id": 2220,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 20",
          "alias_type": "VERSION",
          "id": 2221,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 21",
          "alias_type": "VERSION",
          "id": 10,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 5",
          "alias_type": "VERSION",
          "id": 288,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 6",
          "alias_type": "VERSION",
          "id": 289,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 7",
          "alias_type": "VERSION",
          "id": 290,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 8",
          "alias_type": "VERSION",
          "id": 7,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 9",
          "alias_type": "VERSION",
          "id": 2210,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java11",
          "alias_type": "VERSION",
          "id": 2976,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java17",
          "alias_type": "VERSION",
          "id": 2977,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java21",
          "alias_type": "VERSION",
          "id": 2978,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java8",
          "alias_type": "VERSION",
          "id": 2971,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 11",
          "alias_type": "VERSION",
          "id": 21,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 17",
          "alias_type": "VERSION",
          "id": 22,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 21",
          "alias_type": "VERSION",
          "id": 23,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 8",
          "alias_type": "VERSION",
          "id": 20,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 11",
          "alias_type": "VERSION",
          "id": 1512,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 17",
          "alias_type": "VERSION",
          "id": 1513,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 21",
          "alias_type": "VERSION",
          "id": 1514,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 4",
          "alias_type": "VERSION",
          "id": 1496,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 5",
          "alias_type": "VERSION",
          "id": 1497,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 6",
          "alias_type": "VERSION",
          "id": 1498,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 7",
          "alias_type": "VERSION",
          "id": 1499,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 8",
          "alias_type": "VERSION",
          "id": 1500,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java lts",
          "alias_type": "VERSION",
          "id": 3122,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-11",
          "alias_type": "VERSION",
          "id": 1515,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-17",
          "alias_type": "VERSION",
          "id": 1516,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-21",
          "alias_type": "VERSION",
          "id": 1517,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-4",
          "alias_type": "VERSION",
          "id": 1501,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-5",
          "alias_type": "VERSION",
          "id": 1502,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-6",
          "alias_type": "VERSION",
          "id": 1503,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-7",
          "alias_type": "VERSION",
          "id": 1504,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-8",
          "alias_type": "VERSION",
          "id": 1505,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java11",
          "alias_type": "VERSION",
          "id": 1506,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java17",
          "alias_type": "VERSION",
          "id": 1507,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java21",
          "alias_type": "VERSION",
          "id": 1508,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java4",
          "alias_type": "VERSION",
          "id": 1482,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java5",
          "alias_type": "VERSION",
          "id": 1483,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java6",
          "alias_type": "VERSION",
          "id": 1484,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java7",
          "alias_type": "VERSION",
          "id": 1485,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java8",
          "alias_type": "VERSION",
          "id": 1486,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 11",
          "alias_type": "VERSION",
          "id": 1509,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 17",
          "alias_type": "VERSION",
          "id": 1510,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 21",
          "alias_type": "VERSION",
          "id": 1511,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 4",
          "alias_type": "VERSION",
          "id": 1487,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 5",
          "alias_type": "VERSION",
          "id": 1488,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 6",
          "alias_type": "VERSION",
          "id": 1489,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 7",
          "alias_type": "VERSION",
          "id": 1490,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 8",
          "alias_type": "VERSION",
          "id": 1491,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk11",
          "alias_type": "VERSION",
          "id": 1492,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk17",
          "alias_type": "VERSION",
          "id": 1493,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk21",
          "alias_type": "VERSION",
          "id": 1494,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk4",
          "alias_type": "VERSION",
          "id": 1477,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk5",
          "alias_type": "VERSION",
          "id": 1478,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk6",
          "alias_type": "VERSION",
          "id": 1479,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk7",
          "alias_type": "VERSION",
          "id": 1480,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk8",
          "alias_type": "VERSION",
          "id": 1481,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jvm21",
          "alias_type": "VERSION",
          "id": 1495,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Java",
        "id": 1,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "java",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Java Language and JVM",
            "id": 279,
            "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
            "slug": "java-language-and-jvm",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kotlin and Java",
            "id": 161,
            "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
            "slug": "kotlin-and-java",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Pega Programming Languages \u0026 DSLs",
            "id": 267,
            "rationale": "Programming languages and domain-specific languages used in Pega development.",
            "slug": "pega-programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 21,
            "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Java",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Kotlin",
          "alias_type": "CANONICAL",
          "id": 24,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9",
          "alias_type": "VERSION",
          "id": 3102,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.0",
          "alias_type": "VERSION",
          "id": 3104,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.1",
          "alias_type": "VERSION",
          "id": 3105,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.10",
          "alias_type": "VERSION",
          "id": 3107,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.x",
          "alias_type": "VERSION",
          "id": 3106,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin-1.9",
          "alias_type": "VERSION",
          "id": 3103,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Kotlin",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "kotlin",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Java Language and JVM",
            "id": 279,
            "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
            "slug": "java-language-and-jvm",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kotlin and Java",
            "id": 161,
            "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
            "slug": "kotlin-and-java",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Kotlin",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Xcode",
          "alias_type": "CANONICAL",
          "id": 805,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Xcode",
        "id": 479,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "xcode",
        "sub_category_id": 359,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Build and Release Tooling",
            "id": 89,
            "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
            "slug": "build-and-release-tooling",
            "source": "db"
          },
          "input_skill": "Xcode",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Build and Release Tooling",
            "id": 272,
            "rationale": "Tooling used to compile, sign, package, version, and automate release-ready builds for native mobile apps across iOS and Android. This cluster includes platform-specific build systems and release automation used to produce reproducible app artifacts and prepare internal or public release candidates.",
            "slug": "native-mobile-build-and-release-tooling",
            "source": "db"
          },
          "input_skill": "Xcode",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Xcode",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Gradle",
          "alias_type": "CANONICAL",
          "id": 1361,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Gradle",
        "id": 816,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "gradle",
        "sub_category_id": 358,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Build and Dependency Management",
            "id": 286,
            "rationale": "Project build, packaging, and dependency resolution skills used to compile and assemble Java services. This cluster matters because backend delivery depends on reproducible builds and controlled library versions.",
            "slug": "build-and-dependency-management",
            "source": "db"
          },
          "input_skill": "Gradle",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Build and Packaging Tooling",
            "id": 149,
            "rationale": "Tooling used to compile, package, and prepare Ionic apps for development and release. This cluster is coherent because Ionic developers often manage web assets, native wrappers, and environment-specific build outputs.",
            "slug": "build-and-packaging-tooling",
            "source": "db"
          },
          "input_skill": "Gradle",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Build and Release Tooling",
            "id": 89,
            "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
            "slug": "build-and-release-tooling",
            "source": "db"
          },
          "input_skill": "Gradle",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Build and Release Tooling",
            "id": 272,
            "rationale": "Tooling used to compile, sign, package, version, and automate release-ready builds for native mobile apps across iOS and Android. This cluster includes platform-specific build systems and release automation used to produce reproducible app artifacts and prepare internal or public release candidates.",
            "slug": "native-mobile-build-and-release-tooling",
            "source": "db"
          },
          "input_skill": "Gradle",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Gradle",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Android Studio",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Development Environments",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "android-studio",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "SAFe",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodologies",
          "skill_nature": "PRACTICE",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "safe",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Scrum",
          "alias_type": "CANONICAL",
          "id": 1851,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Scrum",
        "id": 1215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "scrum",
        "sub_category_id": 921,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Scrum",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Scrum",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Code Review",
          "alias_type": "CANONICAL",
          "id": 864,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 58,
        "display_name": "Code Review",
        "id": 516,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PRACTICE",
        "slug": "code-review",
        "sub_category_id": 364,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Code Review",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Code Review",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "CI/CD",
          "alias_type": "CANONICAL",
          "id": 1826,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "CI/CD",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "Android Studio",
    "SAFe"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "Frontend Developer",
    "id": 7,
    "rationale": "Domain=Software Engineering \u2192 sub-role react-frontend-developer; The JD is centered on React/TypeScript frontend development, with mobile and CI/CD concerns as supporting responsibilities.",
    "role_archetype": null,
    "slug": "frontend-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "React",
      "tag": "in_db"
    },
    {
      "skill": "React Native",
      "tag": "in_db"
    },
    {
      "skill": "TypeScript",
      "tag": "in_db"
    },
    {
      "skill": "React Query",
      "tag": "in_db"
    },
    {
      "skill": "Jest",
      "tag": "in_db"
    },
    {
      "skill": "GraphQL",
      "tag": "in_db"
    },
    {
      "skill": "REST",
      "tag": "in_db"
    },
    {
      "skill": "Node.js",
      "tag": "in_db"
    },
    {
      "skill": "GitLab CI",
      "tag": "in_db"
    },
    {
      "skill": "GitHub Actions",
      "tag": "in_db"
    },
    {
      "skill": "CircleCI",
      "tag": "in_db"
    },
    {
      "skill": "Objective-C",
      "tag": "in_db"
    },
    {
      "skill": "Swift",
      "tag": "in_db"
    },
    {
      "skill": "Java",
      "tag": "in_db"
    },
    {
      "skill": "Kotlin",
      "tag": "in_db"
    },
    {
      "skill": "Xcode",
      "tag": "in_db"
    },
    {
      "skill": "Gradle",
      "tag": "in_db"
    },
    {
      "skill": "Android Studio",
      "tag": "new"
    },
    {
      "skill": "SAFe",
      "tag": "new"
    },
    {
      "skill": "Scrum",
      "tag": "in_db"
    },
    {
      "skill": "Code Review",
      "tag": "in_db"
    },
    {
      "skill": "CI/CD",
      "tag": "in_db"
    }
  ],
  "llm_cost_api1_usd": null,
  "llm_cost_api2_usd": null,
  "llm_cost_api3_usd": null,
  "llm_cost_total_usd": null,
  "persistence": {
    "items": [
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application Frameworks \u0026 Libraries",
          "id": 451,
          "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
          "slug": "application-frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 451,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frontend Frameworks and Libraries",
          "id": 434,
          "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
          "slug": "frontend-frameworks-and-libraries",
          "source": "db"
        },
        "dimension_id": 434,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Shopify Dev",
            "id": 230,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "shopify-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript for WordPress",
          "id": 329,
          "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
          "slug": "javascript-for-wordpress",
          "source": "db"
        },
        "dimension_id": 329,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "WordPress Dev",
            "id": 227,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "wordpress-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Component Architecture",
          "id": 302,
          "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
          "slug": "react-component-architecture",
          "source": "db"
        },
        "dimension_id": 302,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform Mobile UI Frameworks",
          "id": 319,
          "rationale": "Frameworks, rendering models, and component libraries used to build shared mobile screens, layouts, and interactive experiences across platforms. This includes React Native and related tooling such as React Native CLI and Expo, as well as cross-platform UI libraries and interaction patterns like React Native Paper, NativeBase, gesture handlers, and animated components; it also covers comparable hybrid mobile UI frameworks such as Flutter. Excludes browser-only frontend frameworks and native platform UI toolkits such as SwiftUI, UIKit, Jetpack Compose, and Android Views.",
          "slug": "cross-platform-mobile-ui-frameworks",
          "source": "db"
        },
        "dimension_id": 319,
        "input_skill": "React Native",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1040,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "React Native",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1040,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Integration and Data Fetching",
          "id": 127,
          "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
          "slug": "api-integration-and-data-fetching",
          "source": "db"
        },
        "dimension_id": 127,
        "input_skill": "React Query",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1411,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frontend Testing and E2E Automation",
          "id": 122,
          "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
          "slug": "frontend-testing-and-e2e-automation",
          "source": "db"
        },
        "dimension_id": 122,
        "input_skill": "Jest",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 651,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Mobile Testing Frameworks",
          "id": 168,
          "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
          "slug": "mobile-testing-frameworks",
          "source": "db"
        },
        "dimension_id": 168,
        "input_skill": "Jest",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 651,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Testing and Integration Validation",
          "id": 217,
          "rationale": "Automated checks used to verify feature behavior across client, server, and data boundaries. Full stack engineers rely on this to catch regressions in end-to-end flows and integration points.",
          "slug": "testing-and-integration-validation",
          "source": "db"
        },
        "dimension_id": 217,
        "input_skill": "Jest",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 651,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Design and Contracts",
          "id": 3,
          "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
          "slug": "api-design-and-contracts",
          "source": "db"
        },
        "dimension_id": 3,
        "input_skill": "GraphQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 12,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Integration and Data Fetching",
          "id": 127,
          "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
          "slug": "api-integration-and-data-fetching",
          "source": "db"
        },
        "dimension_id": 127,
        "input_skill": "GraphQL",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 12,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Interface and Contract Design",
          "id": 289,
          "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
          "slug": "api-interface-and-contract-design",
          "source": "db"
        },
        "dimension_id": 289,
        "input_skill": "GraphQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 12,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "External System Integrations",
          "id": 14,
          "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
          "slug": "external-system-integrations",
          "source": "db"
        },
        "dimension_id": 14,
        "input_skill": "GraphQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 12,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Shopify APIs and Webhooks",
          "id": 427,
          "rationale": "Integration work that connects storefronts and apps to external business systems through Shopify interfaces. This cluster is central because Shopify Dev often wires store behavior to inventory, ERP, CRM, and fulfillment systems.",
          "slug": "shopify-apis-and-webhooks",
          "source": "db"
        },
        "dimension_id": 427,
        "input_skill": "GraphQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Shopify Dev",
            "id": 230,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "shopify-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 12,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Design and Contracts",
          "id": 3,
          "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
          "slug": "api-design-and-contracts",
          "source": "db"
        },
        "dimension_id": 3,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Interface and Contract Design",
          "id": 289,
          "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
          "slug": "api-interface-and-contract-design",
          "source": "db"
        },
        "dimension_id": 289,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Integration Protocols \u0026 Standards",
          "id": 271,
          "rationale": "Standards and protocols for integrating Pega applications.",
          "slug": "integration-protocols-standards",
          "source": "db"
        },
        "dimension_id": 271,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Standards \u0026 Protocols Compliance",
          "id": 452,
          "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
          "slug": "standards-protocols-compliance",
          "source": "db"
        },
        "dimension_id": 452,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "Node.js",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1564,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web Application Frameworks",
          "id": 2,
          "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
          "slug": "web-application-frameworks",
          "source": "db"
        },
        "dimension_id": 2,
        "input_skill": "Node.js",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1564,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "GitLab CI",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 282,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD for Machine Learning",
          "id": 56,
          "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
          "slug": "ci-cd-for-machine-learning",
          "source": "db"
        },
        "dimension_id": 56,
        "input_skill": "GitLab CI",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 282,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "GitHub Actions",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 281,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD for Machine Learning",
          "id": 56,
          "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
          "slug": "ci-cd-for-machine-learning",
          "source": "db"
        },
        "dimension_id": 56,
        "input_skill": "GitHub Actions",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 281,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "CircleCI",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 826,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Languages",
          "id": 274,
          "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
          "slug": "native-mobile-languages",
          "source": "db"
        },
        "dimension_id": 274,
        "input_skill": "Objective-C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 441,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Swift and Objective-C",
          "id": 81,
          "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
          "slug": "swift-and-objective-c",
          "source": "db"
        },
        "dimension_id": 81,
        "input_skill": "Objective-C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 441,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Languages",
          "id": 274,
          "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
          "slug": "native-mobile-languages",
          "source": "db"
        },
        "dimension_id": 274,
        "input_skill": "Swift",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 440,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Swift and Objective-C",
          "id": 81,
          "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
          "slug": "swift-and-objective-c",
          "source": "db"
        },
        "dimension_id": 81,
        "input_skill": "Swift",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 440,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Java Language and JVM",
          "id": 279,
          "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
          "slug": "java-language-and-jvm",
          "source": "db"
        },
        "dimension_id": 279,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Kotlin and Java",
          "id": 161,
          "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
          "slug": "kotlin-and-java",
          "source": "db"
        },
        "dimension_id": 161,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Languages",
          "id": 274,
          "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
          "slug": "native-mobile-languages",
          "source": "db"
        },
        "dimension_id": 274,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Pega Programming Languages \u0026 DSLs",
          "id": 267,
          "rationale": "Programming languages and domain-specific languages used in Pega development.",
          "slug": "pega-programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 267,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Java Language and JVM",
          "id": 279,
          "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
          "slug": "java-language-and-jvm",
          "source": "db"
        },
        "dimension_id": 279,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Kotlin and Java",
          "id": 161,
          "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
          "slug": "kotlin-and-java",
          "source": "db"
        },
        "dimension_id": 161,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Languages",
          "id": 274,
          "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
          "slug": "native-mobile-languages",
          "source": "db"
        },
        "dimension_id": 274,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Build and Release Tooling",
          "id": 89,
          "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
          "slug": "build-and-release-tooling",
          "source": "db"
        },
        "dimension_id": 89,
        "input_skill": "Xcode",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 479,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Build and Release Tooling",
          "id": 272,
          "rationale": "Tooling used to compile, sign, package, version, and automate release-ready builds for native mobile apps across iOS and Android. This cluster includes platform-specific build systems and release automation used to produce reproducible app artifacts and prepare internal or public release candidates.",
          "slug": "native-mobile-build-and-release-tooling",
          "source": "db"
        },
        "dimension_id": 272,
        "input_skill": "Xcode",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 479,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Build and Dependency Management",
          "id": 286,
          "rationale": "Project build, packaging, and dependency resolution skills used to compile and assemble Java services. This cluster matters because backend delivery depends on reproducible builds and controlled library versions.",
          "slug": "build-and-dependency-management",
          "source": "db"
        },
        "dimension_id": 286,
        "input_skill": "Gradle",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 816,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Build and Packaging Tooling",
          "id": 149,
          "rationale": "Tooling used to compile, package, and prepare Ionic apps for development and release. This cluster is coherent because Ionic developers often manage web assets, native wrappers, and environment-specific build outputs.",
          "slug": "build-and-packaging-tooling",
          "source": "db"
        },
        "dimension_id": 149,
        "input_skill": "Gradle",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 816,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Build and Release Tooling",
          "id": 89,
          "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
          "slug": "build-and-release-tooling",
          "source": "db"
        },
        "dimension_id": 89,
        "input_skill": "Gradle",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 816,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Build and Release Tooling",
          "id": 272,
          "rationale": "Tooling used to compile, sign, package, version, and automate release-ready builds for native mobile apps across iOS and Android. This cluster includes platform-specific build systems and release automation used to produce reproducible app artifacts and prepare internal or public release candidates.",
          "slug": "native-mobile-build-and-release-tooling",
          "source": "db"
        },
        "dimension_id": 272,
        "input_skill": "Gradle",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 816,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Scrum",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1215,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Code Review",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 516,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "CI/CD",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD for Machine Learning",
          "id": 56,
          "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
          "slug": "ci-cd-for-machine-learning",
          "source": "db"
        },
        "dimension_id": 56,
        "input_skill": "CI/CD",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 0
  },
  "planner_output": null,
  "run_id": "dfdebd26-442a-4d76-a05f-05d75b628284"
}

LLM Calls

Every model call made for this run, in pipeline order. Click a card to see the model's response.

Loading…