← Back to history

Pipeline run

448163ce-0caf-4216-b49a-aae15ff3d625

Pipeline LLM cost (USD)
API 1: $0.0108 API 2: $0.0004 API 3: $0.0000 Total: $0.0113

Client output enrichment

v2 Skill cluster · Nature of work · AI index · Tech stack maturity · Evidence · KRA description
role baseline loaded sources · ai_index: jd · nature_of_work: jd · tech_stack_maturity: jd
Nature of work · End-to-end feature delivery
Build React UI components and Node.js services in JavaScript/TypeScript, wire them to REST APIs on API Gateway/Lambda, and store/process data in DynamoDB. Also write unit tests, deployment scripts, and docs for the shipped features.
"Develop front-end and/or back-end components in these languages"
Tech stack maturity
Modern Cloud Native
The skill set centers on AWS, serverless Lambdas, Docker, DevOps, React, TypeScript, and modern auth/testing practices, which aligns with a cloud-native modern stack.
AI index (0 = no AI use, 5 = totally AI-dependent · v2.1)
0.00 / 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 (39)
JavaScript TypeScript React AWS API Gateway AWS Lambda DynamoDB Node.js Promises Unit Testing REST NPM DevOps AWS Unix Linux Docker Continuous Integration SSO SAML OAuth Code Review Continuous Deployment Cloud Infrastructure GraphQL Python +14
Skill cluster (11 dimension groups, role-scoped)
Programming Languages
JavaScript TypeScript Python C
API Design and Contracts
REST GraphQL
Cloud Platforms
AWS Lambda AWS
Authentication and Session Handling
SAML
CI/CD Pipeline Platforms
DevOps
Containerization and Image Builds
Docker
Relational Data Modeling
MySQL
Relational Database Design
Oracle Database
UI Frameworks and Rendering
React
Web Application Frameworks
Node.js
Cross-cutting / unaligned
AWS API Gateway DynamoDB Promises Unit Testing NPM Unix Linux Continuous Integration SSO OAuth Code Review Continuous Deployment Cloud Infrastructure PHP Monitoring AWS CodeBuild Jenkins IP TCP/IP HTTP SMTP DNS Fault Tolerance High Availability
Show KRA description ↓
• JavaScript/TypeScript • React • API Gateway • Lambda • Dynamo DB • JavaScript/TypeScript • Develop front-end and/or back-end components in these languages • Write unit tests in these languages • Create application deployment scripts in these languages • Understand, create, and leverage promises as the primary mechanism for asynchronous operations • Create or maintain documentation for code written in these languages React : • Build individual UI components in React • Compose React components into full-fledged React apps • Manage application state using modern, async-capable libraries AWS API Gateway : • Design well-conceived internal REST APIs • Publish said APIs to API gateway • Invoke internal and external APIs in a secure manner • Create or maintain documentation for API- s AWS Lambda : • Design application functionality to execute in a serverless environment • Code for AWS Lambda using Node.js • Use and maintain NPM modules AWS DynamoDB : • Design application data for efficient storage and retrieval in a key-value database • Read and write application data using the DynamoDB API • Combine data from multiple DynamoDB tables for processing • 6+ years DevOps experience • Experience with Cloud based infrastructure, ideally Amazon Web Services • Able to define and implement well-written APIs, both for local code and remote protocols (e.g. REST or GraphQL) • Software development experience • Self-driven and requires little guidance on weekly/daily tasks • Aware of current and new technologies • Able to define requirements where no requirements are well defined • You write software • Node.js, Python, PHP, C, etc. • Demonstrated Unix command-line fluency • Able to troubleshoot problems and deliver solution • Demonstrated hands-on experience with systems-level technologies (examples include Linux, Docker, Cloud Infrastructure, monitoring, etc) • Experience with Continuous Integration tools (e.g. Code Build, Jenkins) • Eagerness to learn about new technologies • An understanding of at least 1 database technology, especially DynamoDB, MySQL and Oracle • Exceptional written and verbal communication skills • Experience with SSO vendors and federated auth solutions (SAML, OAuth, etc) • Experience with base layer Internet technologies, IP, TCP/IP, HTTP, SMTP, DNS • Desire to own all aspects of software development life cycle (requirements gathering, software writing, code-reviewing, testing, deploying, patching) • Experience developing continuous deployment pipelines • Experience designing highly available and fault tolerant production architectures in the cloud • Familiarity of the Amazon tools • Ability to follow well-known patterns with consistent naming schemes that anyone can follow • Technical lead on project/product • Mentor other engineers on the team

Signals

Skill full-stack-engineer
0.35
Alias
KRA backend-engineer
0.59

Post-classification

Centroidupdated · n=516
Alias collision log
New-role queue
New skills captured14
New KRA captured

Captured for admin review

AWS API Gateway primary Fullstack Developer pending
DynamoDB primary Fullstack Developer pending
NPM primary Fullstack Developer pending
Unix primary Fullstack Developer pending
Linux primary Fullstack Developer pending
Continuous Integration primary Fullstack Developer pending
AWS CodeBuild Fullstack Developer pending
SSO primary Fullstack Developer pending
IP Fullstack Developer pending
TCP/IP Fullstack Developer pending
SMTP Fullstack Developer pending
Continuous Deployment primary Fullstack Developer pending
Fault Tolerance Fullstack Developer pending
Cloud Infrastructure primary Fullstack Developer pending
Status: completed Created: 2026-05-27T15:42:27.877519Z Updated: 2026-06-12T16:03:18.160772Z API 3 duration: 158593 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

Fullstack Developer

domain · Software Engineering CASE DOMAIN

slug: full-stack-engineer · id: 15 · source: db

Domain=Software Engineering; The JD centers on building React front ends plus Node.js/AWS Lambda/DynamoDB back-end services, APIs, testing, and deployment, which best matches a full-stack role.

Matched skills

JavaScript/TypeScriptReactAPI GatewayLambdaDynamoDBNode.jsPythonPHPUnix command-lineDockerCode BuildJenkinsSSOSAMLOAuth

Matched dimensions

Full-stack application developmentReact UI developmentServerless backend engineeringAPI design and integrationCloud infrastructure and DevOpsCI/CD pipeline developmentDatabase design and data accessAuthentication and federated identity

Matched KRAs

Develop front-end and/or back-end componentsWrite unit tests in these languagesCreate application deployment scriptsBuild individual UI components in ReactDesign well-conceived internal REST APIsPublish said APIs to API gatewayCode for AWS Lambda using Node.jsRead and write application data using the DynamoDB APIOwn all aspects of software development life cycleExperience developing continuous deployment pipelines

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
2
Skipped

Job description

Job description Job Description : KEY RESULT AREAS :

• JavaScript/TypeScript
• React
• API Gateway
• Lambda
• Dynamo DB
• JavaScript/TypeScript
• Develop front-end and/or back-end components in these languages
• Write unit tests in these languages
• Create application deployment scripts in these languages
• Understand, create, and leverage promises as the primary mechanism for asynchronous operations
• Create or maintain documentation for code written in these languages React :
• Build individual UI components in React
• Compose React components into full-fledged React apps
• Manage application state using modern, async-capable libraries AWS API Gateway :
• Design well-conceived internal REST APIs
• Publish said APIs to API gateway
• Invoke internal and external APIs in a secure manner
• Create or maintain documentation for API- s AWS Lambda :
• Design application functionality to execute in a serverless environment
• Code for AWS Lambda using Node.js
• Use and maintain NPM modules AWS DynamoDB :
• Design application data for efficient storage and retrieval in a key-value database
• Read and write application data using the DynamoDB API
• Combine data from multiple DynamoDB tables for processing Requirements:
• Bachelor's degree in computer science
• 6+ years DevOps experience
• Experience with Cloud based infrastructure, ideally Amazon Web Services
• Able to define and implement well-written APIs, both for local code and remote protocols (e.g. REST or GraphQL)
• Software development experience
• Self-driven and requires little guidance on weekly/daily tasks
• Aware of current and new technologies
• Able to define requirements where no requirements are well defined
• You write software
• Node.js, Python, PHP, C, etc.
• Demonstrated Unix command-line fluency
• Able to troubleshoot problems and deliver solution
• Demonstrated hands-on experience with systems-level technologies (examples include Linux, Docker, Cloud Infrastructure, monitoring, etc)
• Experience with Continuous Integration tools (e.g. Code Build, Jenkins)
• Eagerness to learn about new technologies
• An understanding of at least 1 database technology, especially DynamoDB, MySQL and Oracle
• Exceptional written and verbal communication skills
• Experience with SSO vendors and federated auth solutions (SAML, OAuth, etc)
• Experience with base layer Internet technologies, IP, TCP/IP, HTTP, SMTP, DNS
• Desire to own all aspects of software development life cycle (requirements gathering, software writing, code-reviewing, testing, deploying, patching)
• Experience developing continuous deployment pipelines
• Experience designing highly available and fault tolerant production architectures in the cloud
• Familiarity of the Amazon tools
• Ability to follow well-known patterns with consistent naming schemes that anyone can follow
• Technical lead on project/product
• Mentor other engineers on the team

Skills from this JD

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

JavaScript Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: JavaScript id=607 · javascript

Aliases — catalog

  • JavaScript (CANONICAL) primary
  • ES2015 (VERSION)
  • ES2016 (VERSION)
  • ES2017 (VERSION)
  • ES2018 (VERSION)
  • ES2019 (VERSION)
  • ES2020 (VERSION)
  • ES2021 (VERSION)
  • ES2022 (VERSION)
  • ES2023 (VERSION)
  • ES2024 (VERSION)
  • ES5 (VERSION)
  • ES6 (VERSION)
  • JavaScript ES2015 (VERSION)
  • JavaScript ES2020 (VERSION)
  • JavaScript ES6 (VERSION)
  • modern JavaScript (VERSION)

Context tags (catalog)

AJAX Angular Babel DOM DOM manipulation ES6 Express JSON Node.js REST RESTful React TypeScript Vue Vue.js Webpack async/await asynchronous callback callback functions closure event-driven jQuery npm promises

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Mozilla
License
mpl
Year introduced
1995
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: JavaScript appears in a very high volume of job postings across frontend, backend, and full-stack roles, and remains a core language in major ecosystems like Node.js and React.

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

  • JavaScript for WordPress Catalog dimension db id 329

    Library dimension (catalog)

    Roles linked in library: WordPress Dev

  • 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 & DSLs Catalog dimension db id 475

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

  • Programming Languages & Template Languages Catalog dimension db id 359

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Storefront JavaScript and DOM Behavior Catalog dimension db id 422

    Library dimension (catalog)

    Roles linked in library: Shopify 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 skipped (dimension not under chosen role)
JavaScript for WordPress
javascript-for-wordpress
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 saved
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages & Template Languages
programming-languages-template-languages
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)
Storefront JavaScript and DOM Behavior
storefront-javascript-and-dom-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
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 skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
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 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

  • Frameworks & Libraries Catalog dimension db id 360

    Library dimension (catalog)

    Roles linked in library: Drupal Dev, Engineering Manager

  • 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)
Frameworks & Libraries
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
AWS API Gateway Primary 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
Cloud Platforms
Sub-category
general
Skill nature
PLATFORM
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
AWS Lambda Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: AWS Lambda id=2295 · aws-lambda

Aliases — catalog

  • AWS Lambda (CANONICAL) primary

Context tags (catalog)

API Gateway AWS CLI AWS SAM AWS SDK CloudFormation DynamoDB IAM roles Java Lambda@Edge Node.js Python S3 Step Functions X-Ray containerization deployment event-driven microservices monitoring serverless step functions trigger triggers

Stored enrichment (catalog DB)

Category
Service
Sub-category
Serverless Function Service
Vendor
Amazon Web Services
License
other_open
Year introduced
2014
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Broadly listed in cloud/backend JDs and AWS’s serverless docs/marketplace; it’s a standard hiring-pipeline skill for event-driven apps and APIs.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Backend Developer, Cyber Security Engineer, Data Engineer, DevOps Engineer, Fullstack Developer, Go Backend Developer, Java Backend Developer, Kotlin Backend Developer, ML Engineer, MLOps Engineer, Node.js Backend Developer, Python Backend Developer, Scala Backend Developer

  • Cloud Platforms & Hosting Providers Catalog dimension db id 278

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Kotlin Backend Developer, Scala Backend Developer, Web Developer

  • Cloud Platforms & Managed Services Catalog dimension db id 221

    Library dimension (catalog)

    Roles linked in library: Fullstack Developer, Go Backend Developer, Node.js Backend Developer

  • Cloud Platforms & Services Catalog dimension db id 296

    Library dimension (catalog)

    Roles linked in library: Python Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension saved
Cloud Platforms & Hosting Providers
cloud-platforms-hosting-providers
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Platforms & Managed Services
cloud-platforms-managed-services
Existing dimension (library) · Role↔dimension saved
Cloud Platforms & Services
cloud-platforms-services
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DynamoDB Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Amazon DynamoDB id=93 · amazon-dynamodb

Aliases — catalog

  • Amazon DynamoDB (CANONICAL) primary

Context tags (catalog)

AWS SDK DAX GSI LSI NoSQL Streams TTL boto3 conditional writes on-demand capacity partition key provisioned throughput secondary index sort key transactions

Stored enrichment (catalog DB)

Category
Service
Sub-category
Managed Nosql Database Service
Vendor
Amazon Web Services
License
proprietary
Year introduced
2012
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Commonly listed in cloud/backend job descriptions and widely used on AWS; strong vendor adoption and active ecosystem signal broad market demand.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • NoSQL Databases Catalog dimension db id 19

    Library dimension (catalog)

    Roles linked in library: Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
NoSQL Databases
nosql-databases
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
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 skipped (dimension not under chosen role)
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension saved
Promises Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Promises id=2475 · promises

Aliases — catalog

  • Promises (CANONICAL) primary

Context tags (catalog)

JavaScript Promise.all Promise.race async asynchronous await callback catch chaining deferred error handling event loop finally microtask queue then

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Asynchronous Programming
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Promises are a standard JavaScript async primitive and appear routinely in job descriptions for frontend, Node.js, and full-stack roles; they underpin async/await rather than being replaced.

Skill profile (library / DB)

Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
2
Sub-category id
1806
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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unit Testing Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Unit Testing id=517 · unit-testing

Aliases — catalog

  • Unit Testing (CANONICAL)

Context tags (catalog)

JUnit NUnit TDD arrange-act-assert assertions code coverage fixtures mocking pytest regression stubs test cases test doubles test runner xUnit

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Testing Methodology
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Unit testing is a standard hiring requirement across software JDs and appears in mainstream frameworks/docs; GitHub and Stack Overflow usage remain consistently high, with no successor replacing it.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
44
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)
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, 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: Engineering Manager, 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 saved
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)
GraphQL Secondary 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, 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, 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 saved
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)
NPM Primary 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
DevOps Tools
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
DevOps Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: DevOps id=1216 · devops

Aliases — catalog

  • DevOps (CANONICAL)

Context tags (catalog)

Agile Ansible Automation CI/CD Cloud-native Continuous Deployment Continuous Integration Docker GitOps Infrastructure as Code Jenkins Kubernetes Microservices Monitoring SRE Terraform

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Devops Methodology
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: DevOps appears in a large share of software and platform engineering job descriptions, often alongside CI/CD, Kubernetes, and cloud tooling; it is a standard hiring-pipeline keyword rather than a niche specialty.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
922
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

  • Deployment and Release Patterns Catalog dimension db id 140

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, 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)
Deployment and Release Patterns
deployment-and-release-patterns
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Infrastructure as Code
infrastructure-as-code
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: AWS id=187 · aws

Aliases — catalog

  • AWS (CANONICAL) primary

Context tags (catalog)

API Gateway AWS CLI Auto Scaling CloudFormation CloudFront CloudTrail CloudWatch Cognito DynamoDB EC2 ECS EKS Elastic Beanstalk Elastic Load Balancing IAM KMS Lambda RDS Route 53 S3 SNS SQS Serverless VPC

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Cloud Platform
Vendor
Amazon
License
other_open
Year introduced
2006
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: AWS is a hiring-pipeline staple: it appears in a large share of cloud/DevOps job descriptions and dominates public cloud market share, with broad certification and vendor ecosystem support.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Backend Developer, Cyber Security Engineer, Data Engineer, DevOps Engineer, Fullstack Developer, Go Backend Developer, Java Backend Developer, Kotlin Backend Developer, ML Engineer, MLOps Engineer, Node.js Backend Developer, Python Backend Developer, Scala Backend Developer

  • Cloud Platforms for AI Deployment Catalog dimension db id 211

    Library dimension (catalog)

    Roles linked in library: AI Engineer

  • Cloud Provider Platforms Catalog dimension db id 131

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, Cloud Security Engineer

  • Cloud Security Posture Tools Catalog dimension db id 64

    Library dimension (catalog)

    Roles linked in library: Cloud Security Engineer, Cyber Security Engineer

  • Vendor Product Families Catalog dimension db id 477

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension saved
Cloud Platforms for AI Deployment
cloud-platforms-for-ai-deployment
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Vendor Product Families
vendor-product-families
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Python id=5 · python

Aliases — catalog

  • Python (CANONICAL) primary
  • Python 2 (VERSION)
  • Python 2.x (VERSION)
  • Python 3 (VERSION)
  • Python 3.10 (VERSION)
  • Python 3.11 (VERSION)
  • Python 3.12 (VERSION)
  • Python 3.x (VERSION)
  • py (VERSION)
  • py2 (VERSION)
  • py3 (VERSION)
  • python 3 (VERSION)
  • python 3.x (VERSION)
  • python2 (VERSION)
  • python3 (VERSION)
  • python3.x (VERSION)

Context tags (catalog)

API Django FastAPI Flask Jupyter NumPy PEP 8 Pandas REST SQLAlchemy asyncio pandas pip pytest type hints venv virtualenv

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
PSF
License
mit
Year introduced
1991
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
3

Maturity reasoning: Python appears in a very high volume of job descriptions across data, backend, automation, and ML roles, and remains a default hiring-pipeline language on major job boards and tech stacks.

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)

  • Cloud Security Scripting & DSL Languages Catalog dimension db id 248

    Library dimension (catalog)

    Roles linked in library: Cloud Security Engineer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages & DSLs Catalog dimension db id 475

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

  • Programming Languages and Scripting Catalog dimension db id 59

    Library dimension (catalog)

    Roles linked in library: Cyber Security Engineer

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

  • Programming Languages for ML Systems Catalog dimension db id 39

    Library dimension (catalog)

    Roles linked in library: ML Engineer, MLOps Engineer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • Python Programming Catalog dimension db id 290

    Library dimension (catalog)

    Roles linked in library: Python Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages and Scripting
programming-languages-and-scripting
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)
Programming Languages for ML Systems
programming-languages-for-ml-systems
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)
Python Programming
python-programming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PHP Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: PHP id=2986 · php

Aliases — catalog

  • PHP (CANONICAL) primary

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Confidence
0.99
Version strategy
NOT_APPLICABLE

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)

  • PHP and Magento Extension Points Catalog dimension db id 391

    Library dimension (catalog)

    Roles linked in library: Magento Dev

  • PHP and WordPress Hooks Catalog dimension db id 326

    Library dimension (catalog)

    Roles linked in library: WordPress Dev

  • Programming Languages & Template Languages Catalog dimension db id 359

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
PHP and Magento Extension Points
php-and-magento-extension-points
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PHP and WordPress Hooks
php-and-wordpress-hooks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: C# id=4 · c

Aliases — catalog

  • C# (CANONICAL) primary
  • C (CANONICAL)
  • C# 1 (VERSION)
  • C# 10 (VERSION)
  • C# 11 (VERSION)
  • C# 12 (VERSION)
  • C# 13 (VERSION)
  • C# 14 (VERSION)
  • C# 2 (VERSION)
  • C# 3 (VERSION)
  • C# 4 (VERSION)
  • C# 5 (VERSION)
  • C# 6 (VERSION)
  • C# 7 (VERSION)
  • C# 8 (VERSION)
  • C# 9 (VERSION)
  • C# latest (VERSION)
  • C#1 (VERSION)
  • C#10 (VERSION)
  • C#11 (VERSION)
  • C#12 (VERSION)
  • C#2 (VERSION)
  • C#3 (VERSION)
  • C#4 (VERSION)
  • C#5 (VERSION)
  • C#6 (VERSION)
  • C#7 (VERSION)
  • C#8 (VERSION)
  • C#9 (VERSION)
  • C++ (CANONICAL)
  • C++03 (VERSION)
  • C++11 (VERSION)
  • C++14 (VERSION)
  • C++17 (VERSION)
  • C++20 (VERSION)
  • C++23 (VERSION)
  • C++26 (VERSION)
  • C++98 (VERSION)
  • c sharp (VERSION)
  • c# (VERSION)
  • cpp03 (VERSION)
  • cpp11 (VERSION)
  • cpp14 (VERSION)
  • cpp17 (VERSION)
  • cpp20 (VERSION)
  • cpp23 (VERSION)
  • cpp26 (VERSION)
  • cpp98 (VERSION)
  • csharp (VERSION)
  • modern C++ (VERSION)

Context tags (catalog)

.NET ASP.NET Azure Boost C# 9 C11 C99 CLR CMake Entity Framework LINQ MSBuild MVC Makefile NuGet Qt RAII Roslyn STL TDD Unity Visual Studio WPF Web API WinForms Xamarin async/await attributes buffer overflow constexpr delegates dependency injection dynamic memory events free function pointer gcc gdb header files inline interfaces linker malloc memory leak memory management move semantics multithreading operator overloading pointer pointers preprocessor segmentation fault smart pointers stdio.h stdlib.h struct syntax error templates typedef xUnit

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Microsoft
License
mit
Year introduced
2000
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
latest

Maturity reasoning: C# is a mainstream hiring staple with high JD volume across .NET, Azure, and enterprise roles; Microsoft continues active platform investment in .NET, reinforcing broad adoption.

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)

  • C# and .NET Languages Catalog dimension db id 362

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer

  • Cross-Platform App Languages Catalog dimension db id 167

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages for ML Systems Catalog dimension db id 39

    Library dimension (catalog)

    Roles linked in library: ML Engineer, MLOps Engineer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Video Codec Languages and DSLs Catalog dimension db id 225

    Library dimension (catalog)

    Roles linked in library: Video Codec Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
C# and .NET Languages
c-and-net-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
Programming Languages for ML Systems
programming-languages-for-ml-systems
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)
React Frontend Development
d_init_01
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)
Video Codec Languages and DSLs
video-codec-languages-and-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unix Primary 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
Operating Systems
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
Linux Primary 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
Operating Systems
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
Docker Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Docker id=61 · docker

Aliases — catalog

  • Docker (CANONICAL) primary

Context tags (catalog)

CI/CD Compose DevOps Docker Compose Docker Swarm Dockerfile Kubernetes build pipeline container container lifecycle container orchestration container registry container security containerization containers image image registry images immutable infrastructure lightweight virtualization microservices networking orchestration port mapping registry scalability service discovery swarm volume volume management

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Containerization Tool
Vendor
Docker, Inc.
License
apache_2
Year introduced
2013
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Docker is a hiring-pipeline staple: it appears in many DevOps, backend, and platform JDs, and remains a standard containerization tool alongside Kubernetes in production stacks.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Containerization and Image Builds Catalog dimension db id 152

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Deployment and Cloud Platforms Catalog dimension db id 418

    Library dimension (catalog)

    Roles linked in library: Ruby Backend Developer

  • Deployment and Runtime Configuration Catalog dimension db id 13

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Backend Developer, Go Backend Developer, PHP Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Containerization and Image Builds
containerization-and-image-builds
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Deployment and Cloud Platforms
deployment-and-cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Deployment and Runtime Configuration
deployment-and-runtime-configuration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Monitoring Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Monitoring id=1218 · monitoring

Aliases — catalog

  • Monitoring (CANONICAL)

Context tags (catalog)

ELK Stack Grafana Prometheus SLI SLO alerting anomaly detection dashboards health checks incident response logging metrics monitoring as code observability tracing

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Observability Monitoring
Confidence
0.88
Version strategy
NOT_APPLICABLE

Maturity reasoning: Monitoring is a standard requirement in most SRE/DevOps job descriptions and is bundled into major platforms like AWS CloudWatch, Datadog, and Prometheus, indicating broad market adoption.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Observability and Incident Triage Catalog dimension db id 155

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Observability and Incident Triage
observability-and-incident-triage
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Continuous Integration Primary 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
Practices
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
AWS CodeBuild 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
Cloud Platforms
Sub-category
general
Skill nature
PLATFORM
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Jenkins Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Jenkins id=283 · jenkins

Aliases — catalog

  • Jenkins (CANONICAL) primary

Context tags (catalog)

Blue Ocean CI/CD Declarative Pipeline Docker Groovy Jenkinsfile Kubernetes agents artifact repository artifacts automation build triggers integration multibranch pipeline pipeline plugins shared libraries stages test automation version control webhooks

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Ci Cd Tool
Vendor
CloudBees
License
mit
Year introduced
2011
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Jenkins remains a common CI/CD requirement in job postings and enterprise DevOps stacks, with broad plugin ecosystem and long-running GitHub activity despite newer alternatives.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
184
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)
MySQL Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: MySQL id=17 · mysql

Aliases — catalog

  • MySQL (CANONICAL) primary

Context tags (catalog)

ACID ACID compliance Backup Data Warehousing Database Design ER Diagrams EXPLAIN Indexes InnoDB JOIN Joins MyISAM Normalization PHPMyAdmin Query Optimization Replication SQL SQL queries Stored Procedures Transactions Triggers backup backup and restore backup strategies data modeling data normalization database design database normalization database schema foreign keys indexes indexing joins master-slave normalization performance tuning query optimization read replicas replication schema design schema management sharding stored procedures transaction isolation transaction management transactions triggers

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Relational Database
Vendor
Oracle Corporation
License
gpl_v2
Year introduced
1995
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: MySQL appears in a large share of backend/DB job descriptions and remains a standard managed offering across AWS RDS, Cloud SQL, and Azure Database, indicating broad hiring-pipeline demand.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Relational Data Modeling Catalog dimension db id 216

    Library dimension (catalog)

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

  • Relational Database Design Catalog dimension db id 4

    Library dimension (catalog)

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

  • Relational Database Usage Catalog dimension db id 371

    Library dimension (catalog)

    Roles linked in library: Go Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Relational Data Modeling
relational-data-modeling
Existing dimension (library) · Role↔dimension saved
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Relational Database Usage
relational-database-usage
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Oracle Database Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Oracle Database id=1566 · oracle-database

Aliases — catalog

  • Oracle Database (CANONICAL) primary

Context tags (catalog)

Backup and Recovery Data Guard Data Warehousing Indexing Oracle APEX Oracle Cloud Oracle Enterprise Manager Oracle Exadata Oracle Forms Oracle Fusion Middleware Oracle RAC Oracle SQL Oracle SQL*Plus PL/SQL Partitioning Performance Tuning RMAN SQL Developer

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Relational Database
Vendor
Oracle Corporation
License
proprietary
Year introduced
1979
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Oracle Database appears in many enterprise job postings and remains a standard RDBMS in large regulated environments; Oracle continues active vendor support and releases, indicating broad market demand.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Relational Database Design Catalog dimension db id 4

    Library dimension (catalog)

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

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)
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SSO Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: SSO federation id=745 · sso-federation

Aliases — catalog

  • SSO federation (CANONICAL) primary

Context tags (catalog)

ADFS Azure AD IdP JWT OAuth 2.0 Okta OpenID Connect SAML SCIM SP assertion claims mapping federated identity metadata exchange single sign-on

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Identity Federation Concept
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Common in enterprise JDs for Okta/Azure AD/SAML/OIDC integrations; widely required for SaaS and internal app access control.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Identity and Access Architecture Catalog dimension db id 137

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, Cloud Security Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Identity and Access Architecture
identity-and-access-architecture
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
SAML Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: SAML id=30 · saml

Aliases — catalog

  • SAML (CANONICAL) primary

Context tags (catalog)

ACS URL ADFS IdP IdP-initiated NameID OAuth Okta OpenID OpenID Connect SAML 2.0 SAML assertions SP SP-initiated SSO Shibboleth X.509 certificate XML assertion authentication authentication flow authorization binding federation identity federation identity provider metadata metadata XML request response security token security tokens service provider single sign-on user authentication

Stored enrichment (catalog DB)

Category
Protocol
Sub-category
Authentication Protocol
Vendor
OASIS
License
other_open
Year introduced
2001
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: Commonly listed in enterprise IAM/SSO job descriptions and supported by major vendors like Okta, Azure AD, and Ping; still widely used for federation alongside OIDC.

Skill profile (library / DB)

Skill nature
PROTOCOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
10
Sub-category id
2447
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Authentication and Authorization Catalog dimension db id 6

    Library dimension (catalog)

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

  • Authentication and Identity Integration Catalog dimension db id 351

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

  • Authentication and Session Handling Catalog dimension db id 86

    Library dimension (catalog)

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

  • Backend Authentication and Authorization Catalog dimension db id 386

    Library dimension (catalog)

    Roles linked in library: Kotlin 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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Authentication and Authorization
authentication-and-authorization
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Authentication and Identity Integration
authentication-and-identity-integration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Authentication and Session Handling
authentication-and-session-handling
Existing dimension (library) · Role↔dimension saved
Backend Authentication and Authorization
backend-authentication-and-authorization
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)
OAuth Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: OAuth id=4066 · oauth

Aliases — catalog

  • OAuth (CANONICAL) primary

Context tags (catalog)

Bearer token JWT OAuth 2.0 OpenID PKCE authorization code authorization server client credentials grant types implicit flow redirect URI refresh token resource server scopes token endpoint

Stored enrichment (catalog DB)

Category
Protocol
Sub-category
Authorization Protocol
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: OAuth is widely listed in job descriptions for API/auth work and is a standard authorization protocol across major vendors; OAuth 2.0/OIDC are common requirements in modern identity stacks.

Skill profile (library / DB)

Skill nature
PROTOCOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
10
Sub-category id
50
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • 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
Shopify APIs and Webhooks
shopify-apis-and-webhooks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
IP 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
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
TCP/IP 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
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
HTTP Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: HTTP id=935 · http

Aliases — catalog

  • HTTP (CANONICAL) primary

Context tags (catalog)

API CORS HTTPS REST URI WebSocket client-server content negotiation cookies header fields load balancing proxy request-response session management status codes

Stored enrichment (catalog DB)

Category
Protocol
Sub-category
Application Protocol
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: HTTP is a foundational web protocol present in nearly all backend/frontend JDs and cloud docs; it underpins REST APIs and browser traffic, with no successor replacing it.

Skill profile (library / DB)

Skill nature
PROTOCOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
10
Sub-category id
710
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Networking and API Integration Catalog dimension db id 84

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Networking and API Integration
networking-and-api-integration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SMTP 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
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
DNS Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: DNS id=740 · dns

Aliases — catalog

  • DNS (CANONICAL) primary

Context tags (catalog)

A record BIND CNAME DNS caching DNS over HTTPS DNS query DNS server DNSSEC MX record NS record PTR record SOA TTL authoritative server dynamic DNS forward lookup forwarding recursive resolver reverse lookup root nameserver split-horizon DNS zone file

Stored enrichment (catalog DB)

Category
Protocol
Sub-category
Name Resolution Protocol
Vendor
IETF
License
other_open
Year introduced
1983
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: DNS is a foundational internet protocol and appears routinely in SRE, network, and cloud job descriptions; major vendors still document and support it as core infrastructure.

Skill profile (library / DB)

Skill nature
PROTOCOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
10
Sub-category id
561
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cloud Networking and Connectivity Catalog dimension db id 153

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Cloud Networking and Edge Connectivity Catalog dimension db id 136

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Networking and Connectivity
cloud-networking-and-connectivity
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Networking and Edge Connectivity
cloud-networking-and-edge-connectivity
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Code Review Primary 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)
Continuous Deployment Primary 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
Practices
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Fault Tolerance 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
Concepts
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
High Availability Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: high availability id=764 · high-availability

Aliases — catalog

  • high availability (CANONICAL) primary

Context tags (catalog)

RPO RTO SLA active-active active-passive clustering disaster recovery failover fault tolerance heartbeat load balancing redundancy replication rolling upgrade zero downtime

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Reliability Concept
Confidence
0.92
Version strategy
NOT_APPLICABLE

Maturity reasoning: High availability is a standard requirement in cloud/SRE job descriptions and vendor docs; AWS, Azure, and GCP all publish HA reference architectures, showing broad market adoption.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Availability and Disaster Recovery Catalog dimension db id 141

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Availability and Disaster Recovery
availability-and-disaster-recovery
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Infrastructure Primary 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
Cloud Platforms
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED

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
JavaScript in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
JavaScript in_db
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Storefront JavaScript and DOM Behavior
storefront-javascript-and-dom-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
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 skipped (dimension not under chosen role)
TypeScript in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
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 in_db
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
Frameworks & Libraries
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
AWS Lambda in_db
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension saved
AWS Lambda in_db
Cloud Platforms & Hosting Providers
cloud-platforms-hosting-providers
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS Lambda in_db
Cloud Platforms & Managed Services
cloud-platforms-managed-services
Existing dimension (library) · Role↔dimension saved
AWS Lambda in_db
Cloud Platforms & Services
cloud-platforms-services
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DynamoDB new
NoSQL Databases
nosql-databases
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed
Node.js in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Node.js in_db
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension saved
Promises in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unit Testing in_db
React Frontend Development
d_init_01
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 saved
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)
GraphQL in_db
API Design and Contracts
api-design-and-contracts
Existing dimension (library) · Role↔dimension saved
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)
DevOps in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DevOps in_db
Deployment and Release Patterns
deployment-and-release-patterns
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DevOps in_db
Infrastructure as Code
infrastructure-as-code
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension saved
AWS in_db
Cloud Platforms for AI Deployment
cloud-platforms-for-ai-deployment
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Vendor Product Families
vendor-product-families
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
Python in_db
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages and Scripting
programming-languages-and-scripting
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Python Programming
python-programming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PHP in_db
PHP and Magento Extension Points
php-and-magento-extension-points
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PHP in_db
PHP and WordPress Hooks
php-and-wordpress-hooks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PHP in_db
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
C# and .NET Languages
c-and-net-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
C in_db
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Video Codec Languages and DSLs
video-codec-languages-and-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Containerization and Image Builds
containerization-and-image-builds
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Deployment and Cloud Platforms
deployment-and-cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Deployment and Runtime Configuration
deployment-and-runtime-configuration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Monitoring in_db
Observability and Incident Triage
observability-and-incident-triage
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Jenkins in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Jenkins in_db
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL in_db
Relational Data Modeling
relational-data-modeling
Existing dimension (library) · Role↔dimension saved
MySQL in_db
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL in_db
Relational Database Usage
relational-database-usage
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Oracle Database in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Oracle Database in_db
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SSO new
Identity and Access Architecture
identity-and-access-architecture
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed
SAML in_db
Authentication and Authorization
authentication-and-authorization
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SAML in_db
Authentication and Identity Integration
authentication-and-identity-integration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SAML in_db
Authentication and Session Handling
authentication-and-session-handling
Existing dimension (library) · Role↔dimension saved
SAML in_db
Backend Authentication and Authorization
backend-authentication-and-authorization
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SAML in_db
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
OAuth in_db
Shopify APIs and Webhooks
shopify-apis-and-webhooks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTTP in_db
Networking and API Integration
networking-and-api-integration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DNS in_db
Cloud Networking and Connectivity
cloud-networking-and-connectivity
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DNS in_db
Cloud Networking and Edge Connectivity
cloud-networking-and-edge-connectivity
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)
High Availability in_db
Availability and Disaster Recovery
availability-and-disaster-recovery
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed AWS API Gateway | type=Cloud Platforms subtype=general nature=PLATFORM lifespan=MULTI_YEAR
canonical_skill_proposed NPM | type=DevOps Tools subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed Unix | type=Operating Systems subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed Linux | type=Operating Systems subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed Continuous Integration | type=Practices subtype=general nature=PRACTICE lifespan=MULTI_YEAR
canonical_skill_proposed AWS CodeBuild | type=Cloud Platforms subtype=general nature=PLATFORM lifespan=MULTI_YEAR
canonical_skill_proposed IP | type=Networking subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed TCP/IP | type=Networking subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed SMTP | type=Networking subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed Continuous Deployment | type=Practices subtype=general nature=PRACTICE lifespan=MULTI_YEAR
canonical_skill_proposed Fault Tolerance | type=Concepts subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed Cloud Infrastructure | type=Cloud Platforms subtype=general nature=CONCEPT lifespan=MULTI_YEAR
dimension_skill_link_proposed DynamoDB ↔ NoSQL Databases
dimension_skill_link_proposed SSO ↔ Identity and Access Architecture
nano JD Parser — gpt-4.1-nano click to toggle
Experience6+ years DevOps experience
DomainIT Services & Consulting
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "archetype_override_applied": true,
  "archetype_override_matched_skills": [
    "Python",
    "GraphQL",
    "Docker",
    "AWS",
    "REST APIs",
    "Jenkins",
    "DevOps",
    "DNS",
    "production",
    "HTTP",
    "Monitoring",
    "APIs",
    "MySQL",
    "API",
    "Cloud",
    "UI Components",
    "SAML",
    "REST",
    "unit tests",
    "Promises",
    "JavaScript",
    "Node.js",
    "PHP",
    "components",
    "Deployment scripts",
    "patching",
    "AWS Lambda",
    "Amazon Web Services",
    "OAuth",
    "TypeScript",
    "React"
  ],
  "certifications": [],
  "company_name": null,
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [],
      "domain": "IT Services \u0026 Consulting"
    },
    "secondary": null
  },
  "education": [
    {
      "level": "Bachelor\u0027s",
      "qualification": "BTECH/BE/BSC - Computer Science",
      "raw": "Bachelor\u0027s degree in computer science",
      "requirement": "required"
    }
  ],
  "experience": {
    "max": null,
    "min": 6,
    "raw": "6+ years DevOps experience"
  },
  "job_locations": [],
  "role": null,
  "role_aliases": [],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 24,
      "heading": "KEY RESULT AREAS",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "\u2022 JavaScript/TypeScript \u2022 React \u2022",
        "last_5_words": "from multiple DynamoDB tables for processing"
      },
      "text": "\u2022 JavaScript/TypeScript\n\u2022 React\n\u2022 API Gateway\n\u2022 Lambda\n\u2022 Dynamo DB\n\u2022 JavaScript/TypeScript\n\u2022 Develop front-end and/or back-end components in these languages\n\u2022 Write unit tests in these languages\n\u2022 Create application deployment scripts in these languages\n\u2022 Understand, create, and leverage promises as the primary mechanism for asynchronous operations\n\u2022 Create or maintain documentation for code written in these languages\nReact :\n\u2022 Build individual UI components in React\n\u2022 Compose React components into full-fledged React apps\n\u2022 Manage application state using modern, async-capable libraries\nAWS API Gateway :\n\u2022 Design well-conceived internal REST APIs\n\u2022 Publish said APIs to API gateway\n\u2022 Invoke internal and external APIs in a secure manner\n\u2022 Create or maintain documentation for API- s\nAWS Lambda :\n\u2022 Design application functionality to execute in a serverless environment\n\u2022 Code for AWS Lambda using Node.js\n\u2022 Use and maintain NPM modules\nAWS DynamoDB :\n\u2022 Design application data for efficient storage and retrieval in a key-value database\n\u2022 Read and write application data using the DynamoDB API\n\u2022 Combine data from multiple DynamoDB tables for processing",
      "word_count": 295
    },
    {
      "bullet_count": 24,
      "heading": "Requirements",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "\u2022 6+ years DevOps experience \u2022",
        "last_5_words": "engineers on the team"
      },
      "text": "\u2022 6+ years DevOps experience\n\u2022 Experience with Cloud based infrastructure, ideally Amazon Web Services\n\u2022 Able to define and implement well-written APIs, both for local code and remote protocols (e.g. REST or GraphQL)\n\u2022 Software development experience\n\u2022 Self-driven and requires little guidance on weekly/daily tasks\n\u2022 Aware of current and new technologies\n\u2022 Able to define requirements where no requirements are well defined\n\u2022 You write software\n\u2022 Node.js, Python, PHP, C, etc.\n\u2022 Demonstrated Unix command-line fluency\n\u2022 Able to troubleshoot problems and deliver solution\n\u2022 Demonstrated hands-on experience with systems-level technologies (examples include Linux, Docker, Cloud Infrastructure, monitoring, etc)\n\u2022 Experience with Continuous Integration tools (e.g. Code Build, Jenkins)\n\u2022 Eagerness to learn about new technologies\n\u2022 An understanding of at least 1 database technology, especially DynamoDB, MySQL and Oracle\n\u2022 Exceptional written and verbal communication skills\n\u2022 Experience with SSO vendors and federated auth solutions (SAML, OAuth, etc)\n\u2022 Experience with base layer Internet technologies, IP, TCP/IP, HTTP, SMTP, DNS\n\u2022 Desire to own all aspects of software development life cycle (requirements gathering, software writing, code-reviewing, testing, deploying, patching)\n\u2022 Experience developing continuous deployment pipelines\n\u2022 Experience designing highly available and fault tolerant production architectures in the cloud\n\u2022 Familiarity of the Amazon tools\n\u2022 Ability to follow well-known patterns with consistent naming schemes that anyone can follow\n\u2022 Technical lead on project/product\n\u2022 Mentor other engineers on the team",
      "word_count": 335
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "JavaScript"
    },
    {
      "is_primary": true,
      "skill_name": "TypeScript"
    },
    {
      "is_primary": true,
      "skill_name": "React"
    },
    {
      "is_primary": true,
      "skill_name": "AWS API Gateway"
    },
    {
      "is_primary": true,
      "skill_name": "AWS Lambda"
    },
    {
      "is_primary": true,
      "skill_name": "DynamoDB"
    },
    {
      "is_primary": true,
      "skill_name": "Node.js"
    },
    {
      "is_primary": true,
      "skill_name": "Promises"
    },
    {
      "is_primary": true,
      "skill_name": "Unit Testing"
    },
    {
      "is_primary": true,
      "skill_name": "REST"
    },
    {
      "is_primary": false,
      "skill_name": "GraphQL"
    },
    {
      "is_primary": true,
      "skill_name": "NPM"
    },
    {
      "is_primary": true,
      "skill_name": "DevOps"
    },
    {
      "is_primary": true,
      "skill_name": "AWS"
    },
    {
      "is_primary": false,
      "skill_name": "Python"
    },
    {
      "is_primary": false,
      "skill_name": "PHP"
    },
    {
      "is_primary": false,
      "skill_name": "C"
    },
    {
      "is_primary": true,
      "skill_name": "Unix"
    },
    {
      "is_primary": true,
      "skill_name": "Linux"
    },
    {
      "is_primary": true,
      "skill_name": "Docker"
    },
    {
      "is_primary": false,
      "skill_name": "Monitoring"
    },
    {
      "is_primary": true,
      "skill_name": "Continuous Integration"
    },
    {
      "is_primary": false,
      "skill_name": "AWS CodeBuild"
    },
    {
      "is_primary": false,
      "skill_name": "Jenkins"
    },
    {
      "is_primary": false,
      "skill_name": "MySQL"
    },
    {
      "is_primary": false,
      "skill_name": "Oracle Database"
    },
    {
      "is_primary": true,
      "skill_name": "SSO"
    },
    {
      "is_primary": true,
      "skill_name": "SAML"
    },
    {
      "is_primary": true,
      "skill_name": "OAuth"
    },
    {
      "is_primary": false,
      "skill_name": "IP"
    },
    {
      "is_primary": false,
      "skill_name": "TCP/IP"
    },
    {
      "is_primary": false,
      "skill_name": "HTTP"
    },
    {
      "is_primary": false,
      "skill_name": "SMTP"
    },
    {
      "is_primary": false,
      "skill_name": "DNS"
    },
    {
      "is_primary": true,
      "skill_name": "Code Review"
    },
    {
      "is_primary": true,
      "skill_name": "Continuous Deployment"
    },
    {
      "is_primary": false,
      "skill_name": "Fault Tolerance"
    },
    {
      "is_primary": false,
      "skill_name": "High Availability"
    },
    {
      "is_primary": true,
      "skill_name": "Cloud Infrastructure"
    }
  ],
  "jd_role": null,
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "archetype_override_applied": true,
    "archetype_override_matched_skills": [
      "Python",
      "GraphQL",
      "Docker",
      "AWS",
      "REST APIs",
      "Jenkins",
      "DevOps",
      "DNS",
      "production",
      "HTTP",
      "Monitoring",
      "APIs",
      "MySQL",
      "API",
      "Cloud",
      "UI Components",
      "SAML",
      "REST",
      "unit tests",
      "Promises",
      "JavaScript",
      "Node.js",
      "PHP",
      "components",
      "Deployment scripts",
      "patching",
      "AWS Lambda",
      "Amazon Web Services",
      "OAuth",
      "TypeScript",
      "React"
    ],
    "certifications": [],
    "company_name": null,
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [],
        "domain": "IT Services \u0026 Consulting"
      },
      "secondary": null
    },
    "education": [
      {
        "level": "Bachelor\u0027s",
        "qualification": "BTECH/BE/BSC - Computer Science",
        "raw": "Bachelor\u0027s degree in computer science",
        "requirement": "required"
      }
    ],
    "experience": {
      "max": null,
      "min": 6,
      "raw": "6+ years DevOps experience"
    },
    "job_locations": [],
    "role": null,
    "role_aliases": [],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 24,
        "heading": "KEY RESULT AREAS",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "\u2022 JavaScript/TypeScript \u2022 React \u2022",
          "last_5_words": "from multiple DynamoDB tables for processing"
        },
        "text": "\u2022 JavaScript/TypeScript\n\u2022 React\n\u2022 API Gateway\n\u2022 Lambda\n\u2022 Dynamo DB\n\u2022 JavaScript/TypeScript\n\u2022 Develop front-end and/or back-end components in these languages\n\u2022 Write unit tests in these languages\n\u2022 Create application deployment scripts in these languages\n\u2022 Understand, create, and leverage promises as the primary mechanism for asynchronous operations\n\u2022 Create or maintain documentation for code written in these languages\nReact :\n\u2022 Build individual UI components in React\n\u2022 Compose React components into full-fledged React apps\n\u2022 Manage application state using modern, async-capable libraries\nAWS API Gateway :\n\u2022 Design well-conceived internal REST APIs\n\u2022 Publish said APIs to API gateway\n\u2022 Invoke internal and external APIs in a secure manner\n\u2022 Create or maintain documentation for API- s\nAWS Lambda :\n\u2022 Design application functionality to execute in a serverless environment\n\u2022 Code for AWS Lambda using Node.js\n\u2022 Use and maintain NPM modules\nAWS DynamoDB :\n\u2022 Design application data for efficient storage and retrieval in a key-value database\n\u2022 Read and write application data using the DynamoDB API\n\u2022 Combine data from multiple DynamoDB tables for processing",
        "word_count": 295
      },
      {
        "bullet_count": 24,
        "heading": "Requirements",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "\u2022 6+ years DevOps experience \u2022",
          "last_5_words": "engineers on the team"
        },
        "text": "\u2022 6+ years DevOps experience\n\u2022 Experience with Cloud based infrastructure, ideally Amazon Web Services\n\u2022 Able to define and implement well-written APIs, both for local code and remote protocols (e.g. REST or GraphQL)\n\u2022 Software development experience\n\u2022 Self-driven and requires little guidance on weekly/daily tasks\n\u2022 Aware of current and new technologies\n\u2022 Able to define requirements where no requirements are well defined\n\u2022 You write software\n\u2022 Node.js, Python, PHP, C, etc.\n\u2022 Demonstrated Unix command-line fluency\n\u2022 Able to troubleshoot problems and deliver solution\n\u2022 Demonstrated hands-on experience with systems-level technologies (examples include Linux, Docker, Cloud Infrastructure, monitoring, etc)\n\u2022 Experience with Continuous Integration tools (e.g. Code Build, Jenkins)\n\u2022 Eagerness to learn about new technologies\n\u2022 An understanding of at least 1 database technology, especially DynamoDB, MySQL and Oracle\n\u2022 Exceptional written and verbal communication skills\n\u2022 Experience with SSO vendors and federated auth solutions (SAML, OAuth, etc)\n\u2022 Experience with base layer Internet technologies, IP, TCP/IP, HTTP, SMTP, DNS\n\u2022 Desire to own all aspects of software development life cycle (requirements gathering, software writing, code-reviewing, testing, deploying, patching)\n\u2022 Experience developing continuous deployment pipelines\n\u2022 Experience designing highly available and fault tolerant production architectures in the cloud\n\u2022 Familiarity of the Amazon tools\n\u2022 Ability to follow well-known patterns with consistent naming schemes that anyone can follow\n\u2022 Technical lead on project/product\n\u2022 Mentor other engineers on the team",
        "word_count": 335
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "448163ce-0caf-4216-b49a-aae15ff3d625",
  "stage3_signals": {
    "alias_found": false,
    "alias_match_roles": [],
    "kra_match_roles": [
      {
        "display_name": "Backend Developer",
        "kra_matches": [
          {
            "kra_text": "Designs and maintains RESTful and GraphQL API interfaces with proper authentication, versioning, rate limiting, and documentation for frontend and third-party consumers.",
            "sentence": "Able to define and implement well-written APIs, both for local code and remote protocols (e.g. REST or GraphQL)",
            "similarity": 0.5992
          },
          {
            "kra_text": "Designs and maintains RESTful and GraphQL API interfaces with proper authentication, versioning, rate limiting, and documentation for frontend and third-party consumers.",
            "sentence": "Design well-conceived internal REST APIs",
            "similarity": 0.5991
          },
          {
            "kra_text": "Configures Docker containers, deployment descriptors, environment variables, and CI/CD pipeline stages for backend service releases.",
            "sentence": "Experience developing continuous deployment pipelines",
            "similarity": 0.5658
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 1,
        "score": 0.588,
        "slug": "backend-engineer",
        "total_count": null
      },
      {
        "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": "Experience developing continuous deployment pipelines",
            "similarity": 0.6092
          },
          {
            "kra_text": "Builds and integrates client-side React or Vue components with server-side Node.js or Django APIs, managing bidirectional data flow across frontend and backend layers.",
            "sentence": "Develop front-end and/or back-end components in these languages",
            "similarity": 0.5998
          },
          {
            "kra_text": "Builds and integrates client-side React or Vue components with server-side Node.js or Django APIs, managing bidirectional data flow across frontend and backend layers.",
            "sentence": "Compose React components into full-fledged React apps",
            "similarity": 0.5324
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 15,
        "score": 0.5805,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Ruby Backend Developer",
        "kra_matches": [
          {
            "kra_text": "internal and external service integration",
            "sentence": "Invoke internal and external APIs in a secure manner",
            "similarity": 0.5865
          },
          {
            "kra_text": "Server-side feature implementation",
            "sentence": "Design application functionality to execute in a serverless environment",
            "similarity": 0.558
          },
          {
            "kra_text": "data access and persistence",
            "sentence": "Design application data for efficient storage and retrieval in a key-value database",
            "similarity": 0.5538
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 85,
        "score": 0.5661,
        "slug": "ruby-backend-developer",
        "total_count": null
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": [
          {
            "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": "Develop front-end and/or back-end components in these languages",
            "similarity": 0.5791
          },
          {
            "kra_text": "Implements client-side state management using Redux, Zustand, Vuex, or Context API to handle complex application data flows and user session state.",
            "sentence": "Manage application state using modern, async-capable libraries",
            "similarity": 0.5744
          },
          {
            "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": "Compose React components into full-fledged React apps",
            "similarity": 0.5287
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 7,
        "score": 0.5607,
        "slug": "frontend-engineer",
        "total_count": null
      },
      {
        "display_name": "Scala Backend Developer",
        "kra_matches": [
          {
            "kra_text": "Server-side feature implementation",
            "sentence": "Design application functionality to execute in a serverless environment",
            "similarity": 0.558
          },
          {
            "kra_text": "internal and external system integration",
            "sentence": "Invoke internal and external APIs in a secure manner",
            "similarity": 0.545
          },
          {
            "kra_text": "application data modeling",
            "sentence": "Design application data for efficient storage and retrieval in a key-value database",
            "similarity": 0.5444
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 87,
        "score": 0.5491,
        "slug": "scala-backend-developer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": 8,
        "matched_skills": [
          "AWS",
          "AWS Lambda",
          "JavaScript",
          "Node.js",
          "REST",
          "React",
          "SAML",
          "TypeScript"
        ],
        "role_id": 15,
        "score": 0.3478,
        "slug": "full-stack-engineer",
        "total_count": 23
      },
      {
        "display_name": "Node.js Backend Developer",
        "kra_matches": null,
        "matched_count": 8,
        "matched_skills": [
          "AWS",
          "AWS Lambda",
          "JavaScript",
          "Node.js",
          "Promises",
          "REST",
          "SAML",
          "TypeScript"
        ],
        "role_id": 82,
        "score": 0.3478,
        "slug": "node-backend-developer",
        "total_count": 23
      },
      {
        "display_name": "Backend Developer",
        "kra_matches": null,
        "matched_count": 8,
        "matched_skills": [
          "AWS",
          "AWS Lambda",
          "Docker",
          "JavaScript",
          "Node.js",
          "REST",
          "SAML",
          "TypeScript"
        ],
        "role_id": 1,
        "score": 0.3478,
        "slug": "backend-engineer",
        "total_count": 23
      },
      {
        "display_name": "Web Developer",
        "kra_matches": null,
        "matched_count": 7,
        "matched_skills": [
          "AWS Lambda",
          "JavaScript",
          "Node.js",
          "Promises",
          "React",
          "SAML",
          "TypeScript"
        ],
        "role_id": 25,
        "score": 0.3043,
        "slug": "web-developer",
        "total_count": 23
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": null,
        "matched_count": 6,
        "matched_skills": [
          "JavaScript",
          "Node.js",
          "Promises",
          "React",
          "SAML",
          "TypeScript"
        ],
        "role_id": 7,
        "score": 0.2609,
        "slug": "frontend-engineer",
        "total_count": 23
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "DOMAIN",
    "chosen_role": {
      "display_name": "Fullstack Developer",
      "kra_matches": null,
      "matched_count": null,
      "matched_skills": null,
      "role_id": 15,
      "score": 0.94,
      "slug": "full-stack-engineer",
      "total_count": null
    },
    "confidence": 0.94,
    "is_new_role": false,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "matched_dimensions": [
      "Full-stack application development",
      "React UI development",
      "Serverless backend engineering",
      "API design and integration",
      "Cloud infrastructure and DevOps",
      "CI/CD pipeline development",
      "Database design and data access",
      "Authentication and federated identity"
    ],
    "matched_kras": [
      "Develop front-end and/or back-end components",
      "Write unit tests in these languages",
      "Create application deployment scripts",
      "Build individual UI components in React",
      "Design well-conceived internal REST APIs",
      "Publish said APIs to API gateway",
      "Code for AWS Lambda using Node.js",
      "Read and write application data using the DynamoDB API",
      "Own all aspects of software development life cycle",
      "Experience developing continuous deployment pipelines"
    ],
    "matched_skills": [
      "JavaScript/TypeScript",
      "React",
      "API Gateway",
      "Lambda",
      "DynamoDB",
      "Node.js",
      "Python",
      "PHP",
      "Unix command-line",
      "Docker",
      "Code Build",
      "Jenkins",
      "SSO",
      "SAML",
      "OAuth"
    ],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "Domain=Software Engineering; The JD centers on building React front ends plus Node.js/AWS Lambda/DynamoDB back-end services, APIs, testing, and deployment, which best matches a full-stack role.",
    "sub_role": null
  },
  "stage5_updates": {
    "centroid_n_after": 516,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": null,
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 15870,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "AWS API Gateway",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15871,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "DynamoDB",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15872,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "NPM",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15873,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "Unix",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15874,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "Linux",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15875,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "Continuous Integration",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 15876,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "AWS CodeBuild",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15877,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "SSO",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 15878,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "IP",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 15879,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "TCP/IP",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 15880,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "SMTP",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15881,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "Continuous Deployment",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 15882,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "Fault Tolerance",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 15883,
        "role_display_name": "Fullstack Developer",
        "role_slug": "full-stack-engineer",
        "skill_name": "Cloud Infrastructure",
        "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": 1028,
      "existing_alias_text": "JavaScript",
      "input_term": "JavaScript",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "JavaScript",
        "id": 607,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "javascript",
        "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": 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": 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": 3563,
      "existing_alias_text": "AWS Lambda",
      "input_term": "AWS Lambda",
      "matched_canonical": {
        "category_id": 11,
        "display_name": "AWS Lambda",
        "id": 2295,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "aws-lambda",
        "sub_category_id": 1704,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": null,
      "existing_alias_text": null,
      "input_term": "DynamoDB",
      "matched_canonical": {
        "category_id": 11,
        "display_name": "Amazon DynamoDB",
        "id": 93,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "amazon-dynamodb",
        "sub_category_id": 55,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_display_name"
    },
    {
      "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": 3812,
      "existing_alias_text": "Promises",
      "input_term": "Promises",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "Promises",
        "id": 2475,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "promises",
        "sub_category_id": 1806,
        "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": 865,
      "existing_alias_text": "Unit Testing",
      "input_term": "Unit Testing",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Unit Testing",
        "id": 517,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "unit-testing",
        "sub_category_id": 44,
        "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": 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": 1852,
      "existing_alias_text": "DevOps",
      "input_term": "DevOps",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "DevOps",
        "id": 1216,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "devops",
        "sub_category_id": 922,
        "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": 406,
      "existing_alias_text": "AWS",
      "input_term": "AWS",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "AWS",
        "id": 187,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "aws",
        "sub_category_id": 46,
        "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": 67,
      "existing_alias_text": "Python",
      "input_term": "Python",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "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": 4444,
      "existing_alias_text": "PHP",
      "input_term": "PHP",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "PHP",
        "id": 2986,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "php",
        "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": 1609,
      "existing_alias_text": "C",
      "input_term": "C",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "C#",
        "id": 4,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "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": 198,
      "existing_alias_text": "Docker",
      "input_term": "Docker",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Docker",
        "id": 61,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "docker",
        "sub_category_id": 63,
        "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": 1854,
      "existing_alias_text": "Monitoring",
      "input_term": "Monitoring",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "Monitoring",
        "id": 1218,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "monitoring",
        "sub_category_id": 924,
        "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": 544,
      "existing_alias_text": "Jenkins",
      "input_term": "Jenkins",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Jenkins",
        "id": 283,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "jenkins",
        "sub_category_id": 184,
        "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": 134,
      "existing_alias_text": "MySQL",
      "input_term": "MySQL",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "MySQL",
        "id": 17,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mysql",
        "sub_category_id": 29,
        "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": 2512,
      "existing_alias_text": "Oracle Database",
      "input_term": "Oracle Database",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "Oracle Database",
        "id": 1566,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "oracle-database",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": 1290,
      "existing_alias_text": "SSO federation",
      "input_term": "SSO",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "SSO federation",
        "id": 745,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "sso-federation",
        "sub_category_id": 532,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 167,
      "existing_alias_text": "SAML",
      "input_term": "SAML",
      "matched_canonical": {
        "category_id": 10,
        "display_name": "SAML",
        "id": 30,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "saml",
        "sub_category_id": 2447,
        "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": 5768,
      "existing_alias_text": "OAuth",
      "input_term": "OAuth",
      "matched_canonical": {
        "category_id": 10,
        "display_name": "OAuth",
        "id": 4066,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "oauth",
        "sub_category_id": 50,
        "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": 1538,
      "existing_alias_text": "HTTP",
      "input_term": "HTTP",
      "matched_canonical": {
        "category_id": 10,
        "display_name": "HTTP",
        "id": 935,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "http",
        "sub_category_id": 710,
        "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": 1285,
      "existing_alias_text": "DNS",
      "input_term": "DNS",
      "matched_canonical": {
        "category_id": 10,
        "display_name": "DNS",
        "id": 740,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "dns",
        "sub_category_id": 561,
        "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": 1309,
      "existing_alias_text": "high availability",
      "input_term": "High Availability",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "high availability",
        "id": 764,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "high-availability",
        "sub_category_id": 535,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "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"
    },
    {
      "display_name": "WordPress Dev",
      "id": 227,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "wordpress-dev",
      "source": "db"
    },
    {
      "display_name": "Pega Developer",
      "id": 24,
      "rationale": null,
      "role_archetype": null,
      "slug": "pega-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": "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": "Engineering Manager",
      "id": 121,
      "rationale": null,
      "role_archetype": null,
      "slug": "engineering-manager",
      "source": "db"
    },
    {
      "display_name": "Drupal Dev",
      "id": 228,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "drupal-dev",
      "source": "db"
    },
    {
      "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": "AR/VR Engineer",
      "id": 8,
      "rationale": null,
      "role_archetype": null,
      "slug": "ar-vr-engineer",
      "source": "db"
    },
    {
      "display_name": ".NET Backend Developer",
      "id": 83,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "dotnet-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Cyber Security Engineer",
      "id": 5,
      "rationale": null,
      "role_archetype": null,
      "slug": "cybersecurity-engineer",
      "source": "db"
    },
    {
      "display_name": "Data Engineer",
      "id": 2,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-engineer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "Go Backend Developer",
      "id": 81,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "go-backend-developer",
      "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": "ML Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-engineer",
      "source": "db"
    },
    {
      "display_name": "MLOps Engineer",
      "id": 16,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-ops-engineer",
      "source": "db"
    },
    {
      "display_name": "Python Backend Developer",
      "id": 80,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "python-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Scala Backend Developer",
      "id": 87,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "scala-backend-developer",
      "source": "db"
    },
    {
      "display_name": "PHP Backend Developer",
      "id": 86,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "php-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Ruby Backend Developer",
      "id": 85,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "ruby-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Cloud Architect",
      "id": 9,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-architect",
      "source": "db"
    },
    {
      "display_name": "AI Engineer",
      "id": 13,
      "rationale": null,
      "role_archetype": null,
      "slug": "ai-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Security Engineer",
      "id": 23,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-security-engineer",
      "source": "db"
    },
    {
      "display_name": "Magento Dev",
      "id": 231,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "magento-dev",
      "source": "db"
    },
    {
      "display_name": "Video Codec Engineer",
      "id": 22,
      "rationale": null,
      "role_archetype": null,
      "slug": "video-codec-engineer",
      "source": "db"
    },
    {
      "display_name": "Android Developer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "android-engineer",
      "source": "db"
    },
    {
      "display_name": "Native Mobile Developer",
      "id": 75,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "native-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "iOS Developer",
      "id": 6,
      "rationale": null,
      "role_archetype": null,
      "slug": "ios-engineer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Fullstack Developer",
    "id": 15,
    "rationale": "Domain=Software Engineering; The JD centers on building React front ends plus Node.js/AWS Lambda/DynamoDB back-end services, APIs, testing, and deployment, which best matches a full-stack role.",
    "role_archetype": null,
    "slug": "full-stack-engineer",
    "source": "db"
  },
  "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": "JavaScript",
      "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": "JavaScript",
      "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": "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": "JavaScript",
      "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": "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": "JavaScript",
      "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": "JavaScript",
      "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"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 DSLs",
        "id": 475,
        "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
        "slug": "programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 Template Languages",
        "id": 359,
        "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
        "slug": "programming-languages-template-languages",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "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": "JavaScript",
      "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": "Storefront JavaScript and DOM Behavior",
        "id": 422,
        "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
        "slug": "storefront-javascript-and-dom-behavior",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "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": "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": 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"
        }
      ]
    },
    {
      "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": "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": "Frameworks \u0026 Libraries",
        "id": 360,
        "rationale": "Manage adoption, integration, and best practices around key software frameworks and libraries.",
        "slug": "frameworks-libraries",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        },
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "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": 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": "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": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "AWS Lambda",
      "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": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        },
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-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": "Cloud Platforms \u0026 Hosting Providers",
        "id": 278,
        "rationale": "Familiarity with vendor-specific hosting and backend services for deploying and scaling web applications.",
        "slug": "cloud-platforms-hosting-providers",
        "source": "db"
      },
      "input_skill": "AWS Lambda",
      "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": "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"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms \u0026 Managed Services",
        "id": 221,
        "rationale": "Operates and integrates vendor-specific cloud compute, storage, and hosting services.",
        "slug": "cloud-platforms-managed-services",
        "source": "db"
      },
      "input_skill": "AWS Lambda",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms \u0026 Services",
        "id": 296,
        "rationale": "Deploying, configuring, and managing Python backends on major cloud and PaaS offerings.",
        "slug": "cloud-platforms-services",
        "source": "db"
      },
      "input_skill": "AWS Lambda",
      "llm_role": null,
      "roles_from_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": "NoSQL Databases",
        "id": 19,
        "rationale": "Models and manages data using non-relational database systems.",
        "slug": "nosql-databases",
        "source": "db"
      },
      "input_skill": "DynamoDB",
      "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"
        }
      ]
    },
    {
      "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": 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": "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": "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": "Promises",
      "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": "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": "Unit Testing",
      "llm_role": null,
      "roles_from_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": 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": "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, Protocols \u0026 Compliance",
        "id": 452,
        "rationale": "Ensure teams adhere to industry standards, security protocols, and regulatory compliance requirements.",
        "slug": "standards-protocols-compliance",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "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 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": 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": "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": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "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": "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": "DevOps",
      "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": "Deployment and Release Patterns",
        "id": 140,
        "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
        "slug": "deployment-and-release-patterns",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "AWS",
      "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": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        },
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-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": "Cloud Platforms for AI Deployment",
        "id": 211,
        "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
        "slug": "cloud-platforms-for-ai-deployment",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Provider Platforms",
        "id": 131,
        "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
        "slug": "cloud-provider-platforms",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Posture Tools",
        "id": 64,
        "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
        "slug": "cloud-security-posture-tools",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        },
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Vendor Product Families",
        "id": 477,
        "rationale": "Coordinate usage, licensing, and architecture decisions for major vendor software and cloud product families.",
        "slug": "vendor-product-families",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Scripting \u0026 DSL Languages",
        "id": 248,
        "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
        "slug": "cloud-security-scripting-dsl-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "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": "Python",
      "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"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 DSLs",
        "id": 475,
        "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
        "slug": "programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages and Scripting",
        "id": 59,
        "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
        "slug": "programming-languages-and-scripting",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-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": "Python",
      "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": "Programming Languages for ML Systems",
        "id": 39,
        "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-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": "Python",
      "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": "Python Programming",
        "id": 290,
        "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
        "slug": "python-programming",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_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": "PHP and Magento Extension Points",
        "id": 391,
        "rationale": "Core implementation surface for Magento customizations, including module code, event-driven hooks, and platform conventions. This is the primary language-and-framework cluster for building upgrade-safe storefront behavior.",
        "slug": "php-and-magento-extension-points",
        "source": "db"
      },
      "input_skill": "PHP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Magento Dev",
          "id": 231,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "magento-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "PHP and WordPress Hooks",
        "id": 326,
        "rationale": "Core implementation language and extension points used to build WordPress behavior. This covers PHP code that powers themes, plugins, and site-specific customizations, plus the hook system that stitches features into WordPress lifecycle events.",
        "slug": "php-and-wordpress-hooks",
        "source": "db"
      },
      "input_skill": "PHP",
      "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": "Programming Languages \u0026 Template Languages",
        "id": 359,
        "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
        "slug": "programming-languages-template-languages",
        "source": "db"
      },
      "input_skill": "PHP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "C# and .NET Languages",
        "id": 362,
        "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
        "slug": "c-and-net-languages",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-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": "C",
      "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": "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": "C",
      "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"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 39,
        "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-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": "C",
      "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": "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": "C",
      "llm_role": null,
      "roles_from_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": "C",
      "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": "Video Codec Languages and DSLs",
        "id": 225,
        "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
        "slug": "video-codec-languages-and-dsls",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Video Codec Engineer",
          "id": 22,
          "rationale": null,
          "role_archetype": null,
          "slug": "video-codec-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Containerization and Image Builds",
        "id": 152,
        "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
        "slug": "containerization-and-image-builds",
        "source": "db"
      },
      "input_skill": "Docker",
      "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": "Deployment and Cloud Platforms",
        "id": 418,
        "rationale": "Platform-as-a-Service and container environments for deploying Ruby applications.",
        "slug": "deployment-and-cloud-platforms",
        "source": "db"
      },
      "input_skill": "Docker",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Runtime Configuration",
        "id": 13,
        "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
        "slug": "deployment-and-runtime-configuration",
        "source": "db"
      },
      "input_skill": "Docker",
      "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": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Observability and Incident Triage",
        "id": 155,
        "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
        "slug": "observability-and-incident-triage",
        "source": "db"
      },
      "input_skill": "Monitoring",
      "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 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": "Jenkins",
      "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": "Jenkins",
      "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": "Relational Data Modeling",
        "id": 216,
        "rationale": "Modeling and tuning relational persistence for backend features. PHP backend developers need this to shape schemas, indexes, transactions, and query-aware data structures that support application behavior.",
        "slug": "relational-data-modeling",
        "source": "db"
      },
      "input_skill": "MySQL",
      "llm_role": null,
      "roles_from_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": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Relational Database Design",
        "id": 4,
        "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
        "slug": "relational-database-design",
        "source": "db"
      },
      "input_skill": "MySQL",
      "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": "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": "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": "Relational Database Usage",
        "id": 371,
        "rationale": "Working effectively with operational relational databases from Go backend services. This includes schema-aware querying, indexing awareness, transactions, and understanding how service code interacts with PostgreSQL or similar systems.",
        "slug": "relational-database-usage",
        "source": "db"
      },
      "input_skill": "MySQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-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": "Oracle Database",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Relational Database Design",
        "id": 4,
        "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
        "slug": "relational-database-design",
        "source": "db"
      },
      "input_skill": "Oracle Database",
      "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": "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": "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": "Identity and Access Architecture",
        "id": 137,
        "rationale": "Cloud identity patterns for authentication, authorization, federation, and privileged access boundaries. This is central to cloud governance because it defines who can administer and consume platform resources.",
        "slug": "identity-and-access-architecture",
        "source": "db"
      },
      "input_skill": "SSO",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Authentication and Authorization",
        "id": 6,
        "rationale": "Identity, session, and access-control mechanisms used to protect PHP backend resources. This includes login flows, token handling, role checks, permissions, and policy enforcement in server-side code.",
        "slug": "authentication-and-authorization",
        "source": "db"
      },
      "input_skill": "SAML",
      "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": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-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": "Authentication and Identity Integration",
        "id": 351,
        "rationale": "Sign-in and identity-related integration work for Drupal sites, including external identity providers and session-related behavior. This is distinct from general permissions because it focuses on how users authenticate and federate into the site.",
        "slug": "authentication-and-identity-integration",
        "source": "db"
      },
      "input_skill": "SAML",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Authentication and Session Handling",
        "id": 86,
        "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
        "slug": "authentication-and-session-handling",
        "source": "db"
      },
      "input_skill": "SAML",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "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": "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": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-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": "Backend Authentication and Authorization",
        "id": 386,
        "rationale": "Identity and access control mechanisms used by backend services to authenticate users or clients and enforce permissions on protected resources. This includes token and session handling, OAuth 2.0 / OpenID Connect / SAML flows, JWT and access tokens, API keys, MFA, role- or claim-based authorization, RBAC/ABAC, scopes, policies, Spring Security, and authorization filters.",
        "slug": "backend-authentication-and-authorization",
        "source": "db"
      },
      "input_skill": "SAML",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-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": "SAML",
      "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": "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": "OAuth",
      "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": "Networking and API Integration",
        "id": 84,
        "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
        "slug": "networking-and-api-integration",
        "source": "db"
      },
      "input_skill": "HTTP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "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": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Networking and Connectivity",
        "id": 153,
        "rationale": "Network primitives and connectivity patterns used to expose services and connect environments. DevOps engineers need this to troubleshoot deployment reachability, ingress, DNS, and environment-to-environment communication.",
        "slug": "cloud-networking-and-connectivity",
        "source": "db"
      },
      "input_skill": "DNS",
      "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": "Cloud Networking and Edge Connectivity",
        "id": 136,
        "rationale": "Network architecture for cloud environments, including segmentation, connectivity, and ingress/egress patterns. Cloud Architects use this to define trust boundaries and workload placement standards.",
        "slug": "cloud-networking-and-edge-connectivity",
        "source": "db"
      },
      "input_skill": "DNS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "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": "Code Review",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Availability and Disaster Recovery",
        "id": 141,
        "rationale": "Resilience architecture for uptime, failover, backup, and recovery objectives. This cluster is coherent because cloud architects must translate business continuity needs into platform guardrails.",
        "slug": "availability-and-disaster-recovery",
        "source": "db"
      },
      "input_skill": "High Availability",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "JavaScript",
    "TypeScript",
    "React",
    "AWS API Gateway",
    "AWS Lambda",
    "DynamoDB",
    "Node.js",
    "Promises",
    "Unit Testing",
    "REST",
    "GraphQL",
    "NPM",
    "DevOps",
    "AWS",
    "Python",
    "PHP",
    "C",
    "Unix",
    "Linux",
    "Docker",
    "Monitoring",
    "Continuous Integration",
    "AWS CodeBuild",
    "Jenkins",
    "MySQL",
    "Oracle Database",
    "SSO",
    "SAML",
    "OAuth",
    "IP",
    "TCP/IP",
    "HTTP",
    "SMTP",
    "DNS",
    "Code Review",
    "Continuous Deployment",
    "Fault Tolerance",
    "High Availability",
    "Cloud Infrastructure"
  ],
  "input_llm_skills": [
    "JavaScript",
    "TypeScript",
    "React",
    "AWS API Gateway",
    "AWS Lambda",
    "DynamoDB",
    "Node.js",
    "Promises",
    "Unit Testing",
    "REST",
    "GraphQL",
    "NPM",
    "DevOps",
    "AWS",
    "Python",
    "PHP",
    "C",
    "Unix",
    "Linux",
    "Docker",
    "Monitoring",
    "Continuous Integration",
    "AWS CodeBuild",
    "Jenkins",
    "MySQL",
    "Oracle Database",
    "SSO",
    "SAML",
    "OAuth",
    "IP",
    "TCP/IP",
    "HTTP",
    "SMTP",
    "DNS",
    "Code Review",
    "Continuous Deployment",
    "Fault Tolerance",
    "High Availability",
    "Cloud Infrastructure"
  ],
  "new_aliases_persisted": 0,
  "run_id": "448163ce-0caf-4216-b49a-aae15ff3d625",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "JavaScript",
          "alias_type": "CANONICAL",
          "id": 1028,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2015",
          "alias_type": "VERSION",
          "id": 1031,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2016",
          "alias_type": "VERSION",
          "id": 1032,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2017",
          "alias_type": "VERSION",
          "id": 1033,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2018",
          "alias_type": "VERSION",
          "id": 1034,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2019",
          "alias_type": "VERSION",
          "id": 1035,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2020",
          "alias_type": "VERSION",
          "id": 1036,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2021",
          "alias_type": "VERSION",
          "id": 1037,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2022",
          "alias_type": "VERSION",
          "id": 1038,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2023",
          "alias_type": "VERSION",
          "id": 1039,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2024",
          "alias_type": "VERSION",
          "id": 1040,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES5",
          "alias_type": "VERSION",
          "id": 1029,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES6",
          "alias_type": "VERSION",
          "id": 1030,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JavaScript ES2015",
          "alias_type": "VERSION",
          "id": 1042,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JavaScript ES2020",
          "alias_type": "VERSION",
          "id": 1043,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JavaScript ES6",
          "alias_type": "VERSION",
          "id": 1041,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "modern JavaScript",
          "alias_type": "VERSION",
          "id": 1044,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "JavaScript",
        "id": 607,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "javascript",
        "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": "JavaScript",
          "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": "JavaScript",
          "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": "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": "JavaScript",
          "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": "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": "JavaScript",
          "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": "JavaScript",
          "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"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \u0026 DSLs",
            "id": 475,
            "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
            "slug": "programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \u0026 Template Languages",
            "id": 359,
            "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
            "slug": "programming-languages-template-languages",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "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": "JavaScript",
          "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": "Storefront JavaScript and DOM Behavior",
            "id": 422,
            "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
            "slug": "storefront-javascript-and-dom-behavior",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "JavaScript",
      "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": 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"
            }
          ]
        },
        {
          "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",
          "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": "React v19",
          "alias_type": "VERSION",
          "id": 6510,
          "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": "react19",
          "alias_type": "VERSION",
          "id": 6500,
          "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": "Frameworks \u0026 Libraries",
            "id": 360,
            "rationale": "Manage adoption, integration, and best practices around key software frameworks and libraries.",
            "slug": "frameworks-libraries",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            },
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "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": 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": "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": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "AWS API Gateway",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Cloud Platforms",
          "skill_nature": "PLATFORM",
          "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": "aws-api-gateway",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "AWS Lambda",
          "alias_type": "CANONICAL",
          "id": 3563,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 11,
        "display_name": "AWS Lambda",
        "id": 2295,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "aws-lambda",
        "sub_category_id": 1704,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "AWS Lambda",
          "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": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            },
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-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": "Cloud Platforms \u0026 Hosting Providers",
            "id": 278,
            "rationale": "Familiarity with vendor-specific hosting and backend services for deploying and scaling web applications.",
            "slug": "cloud-platforms-hosting-providers",
            "source": "db"
          },
          "input_skill": "AWS Lambda",
          "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": "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"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms \u0026 Managed Services",
            "id": 221,
            "rationale": "Operates and integrates vendor-specific cloud compute, storage, and hosting services.",
            "slug": "cloud-platforms-managed-services",
            "source": "db"
          },
          "input_skill": "AWS Lambda",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms \u0026 Services",
            "id": 296,
            "rationale": "Deploying, configuring, and managing Python backends on major cloud and PaaS offerings.",
            "slug": "cloud-platforms-services",
            "source": "db"
          },
          "input_skill": "AWS Lambda",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AWS Lambda",
      "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": "Amazon DynamoDB",
          "alias_type": "CANONICAL",
          "id": 254,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 11,
        "display_name": "Amazon DynamoDB",
        "id": 93,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "amazon-dynamodb",
        "sub_category_id": 55,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "NoSQL Databases",
            "id": 19,
            "rationale": "Models and manages data using non-relational database systems.",
            "slug": "nosql-databases",
            "source": "db"
          },
          "input_skill": "DynamoDB",
          "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"
            }
          ]
        }
      ],
      "input_skill": "DynamoDB",
      "matched_via": "embedding_display_name",
      "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": 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": "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": "Promises",
          "alias_type": "CANONICAL",
          "id": 3812,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "Promises",
        "id": 2475,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "promises",
        "sub_category_id": 1806,
        "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": "Promises",
          "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"
            }
          ]
        }
      ],
      "input_skill": "Promises",
      "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": "Unit Testing",
          "alias_type": "CANONICAL",
          "id": 865,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Unit Testing",
        "id": 517,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "unit-testing",
        "sub_category_id": 44,
        "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": "Unit Testing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Unit Testing",
      "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": 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": "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, Protocols \u0026 Compliance",
            "id": 452,
            "rationale": "Ensure teams adhere to industry standards, security protocols, and regulatory compliance requirements.",
            "slug": "standards-protocols-compliance",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "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": "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": 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": "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": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "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": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "NPM",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "DevOps Tools",
          "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": "npm",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "DevOps",
          "alias_type": "CANONICAL",
          "id": 1852,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "DevOps",
        "id": 1216,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "devops",
        "sub_category_id": 922,
        "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": "DevOps",
          "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": "Deployment and Release Patterns",
            "id": 140,
            "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "slug": "deployment-and-release-patterns",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "DevOps",
      "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": "AWS",
          "alias_type": "CANONICAL",
          "id": 406,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "AWS",
        "id": 187,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "aws",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "AWS",
          "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": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            },
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-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": "Cloud Platforms for AI Deployment",
            "id": 211,
            "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
            "slug": "cloud-platforms-for-ai-deployment",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Provider Platforms",
            "id": 131,
            "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
            "slug": "cloud-provider-platforms",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Posture Tools",
            "id": 64,
            "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
            "slug": "cloud-security-posture-tools",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            },
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Vendor Product Families",
            "id": 477,
            "rationale": "Coordinate usage, licensing, and architecture decisions for major vendor software and cloud product families.",
            "slug": "vendor-product-families",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AWS",
      "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": "Python",
          "alias_type": "CANONICAL",
          "id": 67,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2",
          "alias_type": "VERSION",
          "id": 72,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2.x",
          "alias_type": "VERSION",
          "id": 74,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3",
          "alias_type": "VERSION",
          "id": 73,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.10",
          "alias_type": "VERSION",
          "id": 76,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.11",
          "alias_type": "VERSION",
          "id": 77,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.12",
          "alias_type": "VERSION",
          "id": 78,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.x",
          "alias_type": "VERSION",
          "id": 75,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py",
          "alias_type": "VERSION",
          "id": 2183,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py2",
          "alias_type": "VERSION",
          "id": 68,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py3",
          "alias_type": "VERSION",
          "id": 69,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3",
          "alias_type": "VERSION",
          "id": 2186,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.x",
          "alias_type": "VERSION",
          "id": 2849,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python2",
          "alias_type": "VERSION",
          "id": 70,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3",
          "alias_type": "VERSION",
          "id": 71,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3.x",
          "alias_type": "VERSION",
          "id": 2848,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Scripting \u0026 DSL Languages",
            "id": 248,
            "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
            "slug": "cloud-security-scripting-dsl-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "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": "Python",
          "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"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \u0026 DSLs",
            "id": 475,
            "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
            "slug": "programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages and Scripting",
            "id": 59,
            "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
            "slug": "programming-languages-and-scripting",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-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": "Python",
          "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": "Programming Languages for ML Systems",
            "id": 39,
            "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-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": "Python",
          "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": "Python Programming",
            "id": 290,
            "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
            "slug": "python-programming",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Python",
      "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": "PHP",
          "alias_type": "CANONICAL",
          "id": 4444,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "PHP",
        "id": 2986,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "php",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "PHP and Magento Extension Points",
            "id": 391,
            "rationale": "Core implementation surface for Magento customizations, including module code, event-driven hooks, and platform conventions. This is the primary language-and-framework cluster for building upgrade-safe storefront behavior.",
            "slug": "php-and-magento-extension-points",
            "source": "db"
          },
          "input_skill": "PHP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Magento Dev",
              "id": 231,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "magento-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "PHP and WordPress Hooks",
            "id": 326,
            "rationale": "Core implementation language and extension points used to build WordPress behavior. This covers PHP code that powers themes, plugins, and site-specific customizations, plus the hook system that stitches features into WordPress lifecycle events.",
            "slug": "php-and-wordpress-hooks",
            "source": "db"
          },
          "input_skill": "PHP",
          "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": "Programming Languages \u0026 Template Languages",
            "id": 359,
            "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
            "slug": "programming-languages-template-languages",
            "source": "db"
          },
          "input_skill": "PHP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "PHP",
      "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": "C#",
          "alias_type": "CANONICAL",
          "id": 52,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C",
          "alias_type": "CANONICAL",
          "id": 1609,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 1",
          "alias_type": "VERSION",
          "id": 53,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 10",
          "alias_type": "VERSION",
          "id": 62,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 11",
          "alias_type": "VERSION",
          "id": 63,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 12",
          "alias_type": "VERSION",
          "id": 64,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 13",
          "alias_type": "VERSION",
          "id": 65,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 14",
          "alias_type": "VERSION",
          "id": 66,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 2",
          "alias_type": "VERSION",
          "id": 54,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 3",
          "alias_type": "VERSION",
          "id": 55,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 4",
          "alias_type": "VERSION",
          "id": 56,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 5",
          "alias_type": "VERSION",
          "id": 57,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 6",
          "alias_type": "VERSION",
          "id": 58,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 7",
          "alias_type": "VERSION",
          "id": 59,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 8",
          "alias_type": "VERSION",
          "id": 60,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 9",
          "alias_type": "VERSION",
          "id": 61,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# latest",
          "alias_type": "VERSION",
          "id": 1655,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#1",
          "alias_type": "VERSION",
          "id": 2228,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#10",
          "alias_type": "VERSION",
          "id": 2246,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#11",
          "alias_type": "VERSION",
          "id": 2247,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#12",
          "alias_type": "VERSION",
          "id": 2248,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#2",
          "alias_type": "VERSION",
          "id": 2229,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#3",
          "alias_type": "VERSION",
          "id": 2230,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#4",
          "alias_type": "VERSION",
          "id": 2231,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#5",
          "alias_type": "VERSION",
          "id": 2232,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#6",
          "alias_type": "VERSION",
          "id": 2233,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#7",
          "alias_type": "VERSION",
          "id": 2234,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#8",
          "alias_type": "VERSION",
          "id": 2235,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#9",
          "alias_type": "VERSION",
          "id": 2236,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++",
          "alias_type": "CANONICAL",
          "id": 418,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++03",
          "alias_type": "VERSION",
          "id": 420,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++11",
          "alias_type": "VERSION",
          "id": 421,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++14",
          "alias_type": "VERSION",
          "id": 422,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++17",
          "alias_type": "VERSION",
          "id": 423,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++20",
          "alias_type": "VERSION",
          "id": 424,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++23",
          "alias_type": "VERSION",
          "id": 425,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++26",
          "alias_type": "VERSION",
          "id": 426,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++98",
          "alias_type": "VERSION",
          "id": 427,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "c sharp",
          "alias_type": "VERSION",
          "id": 4765,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "c#",
          "alias_type": "VERSION",
          "id": 4763,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp03",
          "alias_type": "VERSION",
          "id": 879,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp11",
          "alias_type": "VERSION",
          "id": 880,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp14",
          "alias_type": "VERSION",
          "id": 881,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp17",
          "alias_type": "VERSION",
          "id": 882,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp20",
          "alias_type": "VERSION",
          "id": 883,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp23",
          "alias_type": "VERSION",
          "id": 884,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp26",
          "alias_type": "VERSION",
          "id": 885,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp98",
          "alias_type": "VERSION",
          "id": 886,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "csharp",
          "alias_type": "VERSION",
          "id": 4764,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "modern C++",
          "alias_type": "VERSION",
          "id": 428,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "C#",
        "id": 4,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "c",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "C# and .NET Languages",
            "id": 362,
            "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
            "slug": "c-and-net-languages",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-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": "C",
          "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": "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": "C",
          "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"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 39,
            "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-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": "C",
          "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": "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": "C",
          "llm_role": null,
          "roles_from_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": "C",
          "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": "Video Codec Languages and DSLs",
            "id": 225,
            "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
            "slug": "video-codec-languages-and-dsls",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Video Codec Engineer",
              "id": 22,
              "rationale": null,
              "role_archetype": null,
              "slug": "video-codec-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "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": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Unix",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Operating Systems",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "unix",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Linux",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Operating Systems",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "linux",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Docker",
          "alias_type": "CANONICAL",
          "id": 198,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Docker",
        "id": 61,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "docker",
        "sub_category_id": 63,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Containerization and Image Builds",
            "id": 152,
            "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
            "slug": "containerization-and-image-builds",
            "source": "db"
          },
          "input_skill": "Docker",
          "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": "Deployment and Cloud Platforms",
            "id": 418,
            "rationale": "Platform-as-a-Service and container environments for deploying Ruby applications.",
            "slug": "deployment-and-cloud-platforms",
            "source": "db"
          },
          "input_skill": "Docker",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Runtime Configuration",
            "id": 13,
            "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
            "slug": "deployment-and-runtime-configuration",
            "source": "db"
          },
          "input_skill": "Docker",
          "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": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Docker",
      "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": "Monitoring",
          "alias_type": "CANONICAL",
          "id": 1854,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "Monitoring",
        "id": 1218,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "monitoring",
        "sub_category_id": 924,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Observability and Incident Triage",
            "id": 155,
            "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
            "slug": "observability-and-incident-triage",
            "source": "db"
          },
          "input_skill": "Monitoring",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Monitoring",
      "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": "Continuous Integration",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Practices",
          "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": "continuous-integration",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "AWS CodeBuild",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Cloud Platforms",
          "skill_nature": "PLATFORM",
          "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": "aws-codebuild",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Jenkins",
          "alias_type": "CANONICAL",
          "id": 544,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Jenkins",
        "id": 283,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "jenkins",
        "sub_category_id": 184,
        "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": "Jenkins",
          "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": "Jenkins",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Jenkins",
      "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": "MySQL",
          "alias_type": "CANONICAL",
          "id": 134,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "MySQL",
        "id": 17,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mysql",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Data Modeling",
            "id": 216,
            "rationale": "Modeling and tuning relational persistence for backend features. PHP backend developers need this to shape schemas, indexes, transactions, and query-aware data structures that support application behavior.",
            "slug": "relational-data-modeling",
            "source": "db"
          },
          "input_skill": "MySQL",
          "llm_role": null,
          "roles_from_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": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Database Design",
            "id": 4,
            "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
            "slug": "relational-database-design",
            "source": "db"
          },
          "input_skill": "MySQL",
          "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": "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": "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": "Relational Database Usage",
            "id": 371,
            "rationale": "Working effectively with operational relational databases from Go backend services. This includes schema-aware querying, indexing awareness, transactions, and understanding how service code interacts with PostgreSQL or similar systems.",
            "slug": "relational-database-usage",
            "source": "db"
          },
          "input_skill": "MySQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "MySQL",
      "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": "Oracle Database",
          "alias_type": "CANONICAL",
          "id": 2512,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "Oracle Database",
        "id": 1566,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "oracle-database",
        "sub_category_id": 29,
        "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": "Oracle Database",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Database Design",
            "id": 4,
            "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
            "slug": "relational-database-design",
            "source": "db"
          },
          "input_skill": "Oracle Database",
          "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": "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": "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"
            }
          ]
        }
      ],
      "input_skill": "Oracle Database",
      "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": "SSO federation",
          "alias_type": "CANONICAL",
          "id": 1290,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "SSO federation",
        "id": 745,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "sso-federation",
        "sub_category_id": 532,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Identity and Access Architecture",
            "id": 137,
            "rationale": "Cloud identity patterns for authentication, authorization, federation, and privileged access boundaries. This is central to cloud governance because it defines who can administer and consume platform resources.",
            "slug": "identity-and-access-architecture",
            "source": "db"
          },
          "input_skill": "SSO",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "SSO",
      "matched_via": "embedding_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": "SAML",
          "alias_type": "CANONICAL",
          "id": 167,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 10,
        "display_name": "SAML",
        "id": 30,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "saml",
        "sub_category_id": 2447,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Authentication and Authorization",
            "id": 6,
            "rationale": "Identity, session, and access-control mechanisms used to protect PHP backend resources. This includes login flows, token handling, role checks, permissions, and policy enforcement in server-side code.",
            "slug": "authentication-and-authorization",
            "source": "db"
          },
          "input_skill": "SAML",
          "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": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-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": "Authentication and Identity Integration",
            "id": 351,
            "rationale": "Sign-in and identity-related integration work for Drupal sites, including external identity providers and session-related behavior. This is distinct from general permissions because it focuses on how users authenticate and federate into the site.",
            "slug": "authentication-and-identity-integration",
            "source": "db"
          },
          "input_skill": "SAML",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Authentication and Session Handling",
            "id": 86,
            "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
            "slug": "authentication-and-session-handling",
            "source": "db"
          },
          "input_skill": "SAML",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "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": "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": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-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": "Backend Authentication and Authorization",
            "id": 386,
            "rationale": "Identity and access control mechanisms used by backend services to authenticate users or clients and enforce permissions on protected resources. This includes token and session handling, OAuth 2.0 / OpenID Connect / SAML flows, JWT and access tokens, API keys, MFA, role- or claim-based authorization, RBAC/ABAC, scopes, policies, Spring Security, and authorization filters.",
            "slug": "backend-authentication-and-authorization",
            "source": "db"
          },
          "input_skill": "SAML",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-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": "SAML",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "SAML",
      "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": "OAuth",
          "alias_type": "CANONICAL",
          "id": 5768,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 10,
        "display_name": "OAuth",
        "id": 4066,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "oauth",
        "sub_category_id": 50,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "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": "OAuth",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "OAuth",
      "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": "IP",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "ip",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "TCP/IP",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "tcp-ip",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "HTTP",
          "alias_type": "CANONICAL",
          "id": 1538,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 10,
        "display_name": "HTTP",
        "id": 935,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "http",
        "sub_category_id": 710,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Networking and API Integration",
            "id": 84,
            "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "slug": "networking-and-api-integration",
            "source": "db"
          },
          "input_skill": "HTTP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "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": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "HTTP",
      "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": "SMTP",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "smtp",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "DNS",
          "alias_type": "CANONICAL",
          "id": 1285,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 10,
        "display_name": "DNS",
        "id": 740,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "dns",
        "sub_category_id": 561,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Networking and Connectivity",
            "id": 153,
            "rationale": "Network primitives and connectivity patterns used to expose services and connect environments. DevOps engineers need this to troubleshoot deployment reachability, ingress, DNS, and environment-to-environment communication.",
            "slug": "cloud-networking-and-connectivity",
            "source": "db"
          },
          "input_skill": "DNS",
          "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": "Cloud Networking and Edge Connectivity",
            "id": 136,
            "rationale": "Network architecture for cloud environments, including segmentation, connectivity, and ingress/egress patterns. Cloud Architects use this to define trust boundaries and workload placement standards.",
            "slug": "cloud-networking-and-edge-connectivity",
            "source": "db"
          },
          "input_skill": "DNS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "DNS",
      "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": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Continuous Deployment",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Practices",
          "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": "continuous-deployment",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Fault Tolerance",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concepts",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "fault-tolerance",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "high availability",
          "alias_type": "CANONICAL",
          "id": 1309,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "high availability",
        "id": 764,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "high-availability",
        "sub_category_id": 535,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Availability and Disaster Recovery",
            "id": 141,
            "rationale": "Resilience architecture for uptime, failover, backup, and recovery objectives. This cluster is coherent because cloud architects must translate business continuity needs into platform guardrails.",
            "slug": "availability-and-disaster-recovery",
            "source": "db"
          },
          "input_skill": "High Availability",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "High Availability",
      "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": "Cloud Infrastructure",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Cloud Platforms",
          "skill_nature": "CONCEPT",
          "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": "cloud-infrastructure",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "AWS API Gateway",
    "NPM",
    "Unix",
    "Linux",
    "Continuous Integration",
    "AWS CodeBuild",
    "IP",
    "TCP/IP",
    "SMTP",
    "Continuous Deployment",
    "Fault Tolerance",
    "Cloud Infrastructure"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "Fullstack Developer",
    "id": 15,
    "rationale": "Domain=Software Engineering; The JD centers on building React front ends plus Node.js/AWS Lambda/DynamoDB back-end services, APIs, testing, and deployment, which best matches a full-stack role.",
    "role_archetype": null,
    "slug": "full-stack-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "JavaScript",
      "tag": "in_db"
    },
    {
      "skill": "TypeScript",
      "tag": "in_db"
    },
    {
      "skill": "React",
      "tag": "in_db"
    },
    {
      "skill": "AWS API Gateway",
      "tag": "new"
    },
    {
      "skill": "AWS Lambda",
      "tag": "in_db"
    },
    {
      "skill": "DynamoDB",
      "tag": "in_db"
    },
    {
      "skill": "Node.js",
      "tag": "in_db"
    },
    {
      "skill": "Promises",
      "tag": "in_db"
    },
    {
      "skill": "Unit Testing",
      "tag": "in_db"
    },
    {
      "skill": "REST",
      "tag": "in_db"
    },
    {
      "skill": "GraphQL",
      "tag": "in_db"
    },
    {
      "skill": "NPM",
      "tag": "new"
    },
    {
      "skill": "DevOps",
      "tag": "in_db"
    },
    {
      "skill": "AWS",
      "tag": "in_db"
    },
    {
      "skill": "Python",
      "tag": "in_db"
    },
    {
      "skill": "PHP",
      "tag": "in_db"
    },
    {
      "skill": "C",
      "tag": "in_db"
    },
    {
      "skill": "Unix",
      "tag": "new"
    },
    {
      "skill": "Linux",
      "tag": "new"
    },
    {
      "skill": "Docker",
      "tag": "in_db"
    },
    {
      "skill": "Monitoring",
      "tag": "in_db"
    },
    {
      "skill": "Continuous Integration",
      "tag": "new"
    },
    {
      "skill": "AWS CodeBuild",
      "tag": "new"
    },
    {
      "skill": "Jenkins",
      "tag": "in_db"
    },
    {
      "skill": "MySQL",
      "tag": "in_db"
    },
    {
      "skill": "Oracle Database",
      "tag": "in_db"
    },
    {
      "skill": "SSO",
      "tag": "in_db"
    },
    {
      "skill": "SAML",
      "tag": "in_db"
    },
    {
      "skill": "OAuth",
      "tag": "in_db"
    },
    {
      "skill": "IP",
      "tag": "new"
    },
    {
      "skill": "TCP/IP",
      "tag": "new"
    },
    {
      "skill": "HTTP",
      "tag": "in_db"
    },
    {
      "skill": "SMTP",
      "tag": "new"
    },
    {
      "skill": "DNS",
      "tag": "in_db"
    },
    {
      "skill": "Code Review",
      "tag": "in_db"
    },
    {
      "skill": "Continuous Deployment",
      "tag": "new"
    },
    {
      "skill": "Fault Tolerance",
      "tag": "new"
    },
    {
      "skill": "High Availability",
      "tag": "in_db"
    },
    {
      "skill": "Cloud Infrastructure",
      "tag": "new"
    }
  ],
  "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": 15,
        "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": "JavaScript",
        "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": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "JavaScript",
        "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": "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": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "JavaScript",
        "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": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "JavaScript",
        "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": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "JavaScript",
        "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": "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 DSLs",
          "id": 475,
          "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
          "slug": "programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 475,
        "input_skill": "JavaScript",
        "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": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 Template Languages",
          "id": 359,
          "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
          "slug": "programming-languages-template-languages",
          "source": "db"
        },
        "dimension_id": 359,
        "input_skill": "JavaScript",
        "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": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "JavaScript",
        "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": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Storefront JavaScript and DOM Behavior",
          "id": 422,
          "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
          "slug": "storefront-javascript-and-dom-behavior",
          "source": "db"
        },
        "dimension_id": 422,
        "input_skill": "JavaScript",
        "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": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": 15,
        "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": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "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": 15,
        "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": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": 15,
        "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": 15,
        "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frameworks \u0026 Libraries",
          "id": 360,
          "rationale": "Manage adoption, integration, and best practices around key software frameworks and libraries.",
          "slug": "frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 360,
        "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": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          },
          {
            "display_name": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": 15,
        "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": 15,
        "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": 15,
        "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": 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": "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "AWS Lambda",
        "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": ".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": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          },
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-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": 2295,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms \u0026 Hosting Providers",
          "id": 278,
          "rationale": "Familiarity with vendor-specific hosting and backend services for deploying and scaling web applications.",
          "slug": "cloud-platforms-hosting-providers",
          "source": "db"
        },
        "dimension_id": 278,
        "input_skill": "AWS Lambda",
        "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": "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"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2295,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms \u0026 Managed Services",
          "id": 221,
          "rationale": "Operates and integrates vendor-specific cloud compute, storage, and hosting services.",
          "slug": "cloud-platforms-managed-services",
          "source": "db"
        },
        "dimension_id": 221,
        "input_skill": "AWS Lambda",
        "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": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2295,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms \u0026 Services",
          "id": 296,
          "rationale": "Deploying, configuring, and managing Python backends on major cloud and PaaS offerings.",
          "slug": "cloud-platforms-services",
          "source": "db"
        },
        "dimension_id": 296,
        "input_skill": "AWS Lambda",
        "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": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2295,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "NoSQL Databases",
          "id": 19,
          "rationale": "Models and manages data using non-relational database systems.",
          "slug": "nosql-databases",
          "source": "db"
        },
        "dimension_id": 19,
        "input_skill": "DynamoDB",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "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"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 15,
        "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": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "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": 15,
        "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": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "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"
          },
          {
            "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": 15,
        "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": "Promises",
        "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": "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": 2475,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Unit Testing",
        "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": 517,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "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": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": 15,
        "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Standards, Protocols \u0026 Compliance",
          "id": 452,
          "rationale": "Ensure teams adhere to industry standards, security protocols, and regulatory compliance requirements.",
          "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": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "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": 15,
        "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": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "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": 12,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "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": 15,
        "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": 15,
        "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": 15,
        "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": 15,
        "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": "DevOps",
        "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": 1216,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Release Patterns",
          "id": 140,
          "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
          "slug": "deployment-and-release-patterns",
          "source": "db"
        },
        "dimension_id": 140,
        "input_skill": "DevOps",
        "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": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1216,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Infrastructure as Code",
          "id": 132,
          "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
          "slug": "infrastructure-as-code",
          "source": "db"
        },
        "dimension_id": 132,
        "input_skill": "DevOps",
        "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": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1216,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "AWS",
        "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": ".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": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          },
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-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": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms for AI Deployment",
          "id": 211,
          "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
          "slug": "cloud-platforms-for-ai-deployment",
          "source": "db"
        },
        "dimension_id": 211,
        "input_skill": "AWS",
        "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": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Provider Platforms",
          "id": 131,
          "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
          "slug": "cloud-provider-platforms",
          "source": "db"
        },
        "dimension_id": 131,
        "input_skill": "AWS",
        "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": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Posture Tools",
          "id": 64,
          "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
          "slug": "cloud-security-posture-tools",
          "source": "db"
        },
        "dimension_id": 64,
        "input_skill": "AWS",
        "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": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          },
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Vendor Product Families",
          "id": 477,
          "rationale": "Coordinate usage, licensing, and architecture decisions for major vendor software and cloud product families.",
          "slug": "vendor-product-families",
          "source": "db"
        },
        "dimension_id": 477,
        "input_skill": "AWS",
        "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": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Scripting \u0026 DSL Languages",
          "id": 248,
          "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
          "slug": "cloud-security-scripting-dsl-languages",
          "source": "db"
        },
        "dimension_id": 248,
        "input_skill": "Python",
        "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": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Python",
        "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": "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 DSLs",
          "id": 475,
          "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
          "slug": "programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 475,
        "input_skill": "Python",
        "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": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages and Scripting",
          "id": 59,
          "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
          "slug": "programming-languages-and-scripting",
          "source": "db"
        },
        "dimension_id": 59,
        "input_skill": "Python",
        "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": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Python",
        "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": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 39,
          "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 39,
        "input_skill": "Python",
        "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"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Python",
        "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": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Python Programming",
          "id": 290,
          "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
          "slug": "python-programming",
          "source": "db"
        },
        "dimension_id": 290,
        "input_skill": "Python",
        "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": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "PHP and Magento Extension Points",
          "id": 391,
          "rationale": "Core implementation surface for Magento customizations, including module code, event-driven hooks, and platform conventions. This is the primary language-and-framework cluster for building upgrade-safe storefront behavior.",
          "slug": "php-and-magento-extension-points",
          "source": "db"
        },
        "dimension_id": 391,
        "input_skill": "PHP",
        "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": "Magento Dev",
            "id": 231,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "magento-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2986,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "PHP and WordPress Hooks",
          "id": 326,
          "rationale": "Core implementation language and extension points used to build WordPress behavior. This covers PHP code that powers themes, plugins, and site-specific customizations, plus the hook system that stitches features into WordPress lifecycle events.",
          "slug": "php-and-wordpress-hooks",
          "source": "db"
        },
        "dimension_id": 326,
        "input_skill": "PHP",
        "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": 2986,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 Template Languages",
          "id": 359,
          "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
          "slug": "programming-languages-template-languages",
          "source": "db"
        },
        "dimension_id": 359,
        "input_skill": "PHP",
        "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": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2986,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "C# and .NET Languages",
          "id": 362,
          "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
          "slug": "c-and-net-languages",
          "source": "db"
        },
        "dimension_id": 362,
        "input_skill": "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": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "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": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "C",
        "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": "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 39,
          "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 39,
        "input_skill": "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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "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": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "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": [],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "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": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Video Codec Languages and DSLs",
          "id": 225,
          "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
          "slug": "video-codec-languages-and-dsls",
          "source": "db"
        },
        "dimension_id": 225,
        "input_skill": "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": "Video Codec Engineer",
            "id": 22,
            "rationale": null,
            "role_archetype": null,
            "slug": "video-codec-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Containerization and Image Builds",
          "id": 152,
          "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
          "slug": "containerization-and-image-builds",
          "source": "db"
        },
        "dimension_id": 152,
        "input_skill": "Docker",
        "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": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Cloud Platforms",
          "id": 418,
          "rationale": "Platform-as-a-Service and container environments for deploying Ruby applications.",
          "slug": "deployment-and-cloud-platforms",
          "source": "db"
        },
        "dimension_id": 418,
        "input_skill": "Docker",
        "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": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Runtime Configuration",
          "id": 13,
          "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
          "slug": "deployment-and-runtime-configuration",
          "source": "db"
        },
        "dimension_id": 13,
        "input_skill": "Docker",
        "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": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Observability and Incident Triage",
          "id": 155,
          "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
          "slug": "observability-and-incident-triage",
          "source": "db"
        },
        "dimension_id": 155,
        "input_skill": "Monitoring",
        "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": 1218,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Jenkins",
        "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": 283,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Jenkins",
        "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": 283,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Data Modeling",
          "id": 216,
          "rationale": "Modeling and tuning relational persistence for backend features. PHP backend developers need this to shape schemas, indexes, transactions, and query-aware data structures that support application behavior.",
          "slug": "relational-data-modeling",
          "source": "db"
        },
        "dimension_id": 216,
        "input_skill": "MySQL",
        "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": "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": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Design",
          "id": 4,
          "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
          "slug": "relational-database-design",
          "source": "db"
        },
        "dimension_id": 4,
        "input_skill": "MySQL",
        "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": "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": "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": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Usage",
          "id": 371,
          "rationale": "Working effectively with operational relational databases from Go backend services. This includes schema-aware querying, indexing awareness, transactions, and understanding how service code interacts with PostgreSQL or similar systems.",
          "slug": "relational-database-usage",
          "source": "db"
        },
        "dimension_id": 371,
        "input_skill": "MySQL",
        "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": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "Oracle Database",
        "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": 1566,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Design",
          "id": 4,
          "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
          "slug": "relational-database-design",
          "source": "db"
        },
        "dimension_id": 4,
        "input_skill": "Oracle Database",
        "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": "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": "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": 1566,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Identity and Access Architecture",
          "id": 137,
          "rationale": "Cloud identity patterns for authentication, authorization, federation, and privileged access boundaries. This is central to cloud governance because it defines who can administer and consume platform resources.",
          "slug": "identity-and-access-architecture",
          "source": "db"
        },
        "dimension_id": 137,
        "input_skill": "SSO",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Authentication and Authorization",
          "id": 6,
          "rationale": "Identity, session, and access-control mechanisms used to protect PHP backend resources. This includes login flows, token handling, role checks, permissions, and policy enforcement in server-side code.",
          "slug": "authentication-and-authorization",
          "source": "db"
        },
        "dimension_id": 6,
        "input_skill": "SAML",
        "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": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-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": 30,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Authentication and Identity Integration",
          "id": 351,
          "rationale": "Sign-in and identity-related integration work for Drupal sites, including external identity providers and session-related behavior. This is distinct from general permissions because it focuses on how users authenticate and federate into the site.",
          "slug": "authentication-and-identity-integration",
          "source": "db"
        },
        "dimension_id": 351,
        "input_skill": "SAML",
        "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": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 30,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Authentication and Session Handling",
          "id": 86,
          "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
          "slug": "authentication-and-session-handling",
          "source": "db"
        },
        "dimension_id": 86,
        "input_skill": "SAML",
        "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": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "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": "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": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-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": 30,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Backend Authentication and Authorization",
          "id": 386,
          "rationale": "Identity and access control mechanisms used by backend services to authenticate users or clients and enforce permissions on protected resources. This includes token and session handling, OAuth 2.0 / OpenID Connect / SAML flows, JWT and access tokens, API keys, MFA, role- or claim-based authorization, RBAC/ABAC, scopes, policies, Spring Security, and authorization filters.",
          "slug": "backend-authentication-and-authorization",
          "source": "db"
        },
        "dimension_id": 386,
        "input_skill": "SAML",
        "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": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-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": 30,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "SAML",
        "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": 30,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": "OAuth",
        "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": 4066,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Networking and API Integration",
          "id": 84,
          "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
          "slug": "networking-and-api-integration",
          "source": "db"
        },
        "dimension_id": 84,
        "input_skill": "HTTP",
        "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": "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": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 935,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Networking and Connectivity",
          "id": 153,
          "rationale": "Network primitives and connectivity patterns used to expose services and connect environments. DevOps engineers need this to troubleshoot deployment reachability, ingress, DNS, and environment-to-environment communication.",
          "slug": "cloud-networking-and-connectivity",
          "source": "db"
        },
        "dimension_id": 153,
        "input_skill": "DNS",
        "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": 740,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Networking and Edge Connectivity",
          "id": 136,
          "rationale": "Network architecture for cloud environments, including segmentation, connectivity, and ingress/egress patterns. Cloud Architects use this to define trust boundaries and workload placement standards.",
          "slug": "cloud-networking-and-edge-connectivity",
          "source": "db"
        },
        "dimension_id": 136,
        "input_skill": "DNS",
        "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": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 740,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Availability and Disaster Recovery",
          "id": 141,
          "rationale": "Resilience architecture for uptime, failover, backup, and recovery objectives. This cluster is coherent because cloud architects must translate business continuity needs into platform guardrails.",
          "slug": "availability-and-disaster-recovery",
          "source": "db"
        },
        "dimension_id": 141,
        "input_skill": "High Availability",
        "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": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 764,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 2
  },
  "planner_output": null,
  "run_id": "448163ce-0caf-4216-b49a-aae15ff3d625"
}

LLM Calls

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

Loading…