← Back to history

Pipeline run

90a79cd7-55d4-4b8a-a17e-93346336ae76

Pipeline LLM cost (USD)
API 1: $0.0331 API 2: $0.0003 API 3: $0.0000 Total: $0.0334

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 · Responsive UI component development
Build and maintain responsive front-end web apps in AngularJS/React with HTML5, CSS, JS, and MongoDB, turning product ideas into technical solutions while integrating REST/AJAX and working with designers in Agile teams.
""Strong in JavaScript, Angular JS/React JS, Mongo DB""
Tech stack maturity
Mainstream Modern
The skill set centers on widely adopted frontend technologies like Angular, React, HTML5, CSS, and JavaScript, with MongoDB as a common modern datastore rather than a bleeding-edge or legacy 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 (19)
JavaScript AngularJS 1.x React MongoDB HTML5 CSS Bootstrap LESS Sass AJAX REST JSON Test-Driven Development Continuous Integration Agile Scrum Grunt Yeoman OOP JavaScript
Skill cluster (7 dimension groups, role-scoped)
CSS Architecture and Styling
CSS Sass
UI Frameworks and Rendering
AngularJS 1.x React
API Integration and Data Fetching
JSON
Component Libraries and Design Systems
Bootstrap
Integration Protocols & Standards
REST
JavaScript and TypeScript
JavaScript
Cross-cutting / unaligned
MongoDB HTML5 LESS AJAX Test-Driven Development Continuous Integration Agile Scrum Grunt Yeoman OOP JavaScript
Show KRA description ↓
Experience in software development, product development organization experience preferred. Be able to distill business objectives into technical solutions through effective system design and architecture Be able to work independently on a project-by project basis and also work in a collaborative and fast-paced team environment Be able to provide technical and analytical solutions to evaluate the merits and challenges of a product idea 4-9 years of Software Development experience Strong in JavaScript, Angular JS/React JS, Mongo DB Strong Knowledge and proven experience of Semantic HTML5 and Responsive Cross-Platform CSS Knowledge of OOP JavaScript Experience in Bootstrap & Responsive Web Design Hands-on coding experience mandatory Solid written and verbal communication skills Experience in developing web front end apps using AngularJS 1.x, Grunt, Yeoman, etc. Good experience with LESS, SASS, AJAX, REST and JSON Experience with development practices such as Test-Driven Development and Continuous Integration Experience with Agile development methodologies such as Scrum, or at a minimum, a passion to work in an agile environment. Software engineering practices and knowledge of Design Patterns Able to thrive in a fast-paced environment Work in an Agile environment with regular team activities Working closely with product owners and designers. Eye for design aesthetics and attention to detail with a good understanding of UI/UX principles All around team player and self-learning individual Contributor to open-source projects – a plus

Signals

Skill full-stack-engineer
0.50
Alias web-developer
1.00
KRA frontend-engineer
0.59

Post-classification

Centroidupdated · n=55
Alias collision log
New-role queue
New skills captured7
New KRA captured

Captured for admin review

LESS Frontend Developer pending
AJAX Frontend Developer pending
Test-Driven Development Frontend Developer pending
Continuous Integration Frontend Developer pending
Grunt Frontend Developer pending
Yeoman Frontend Developer pending
OOP JavaScript Frontend Developer pending
Status: completed Created: 2026-05-27T13:31:01.508576Z Updated: 2026-05-27T13:31:50.989452Z API 3 duration: 9889 ms
Flow Current 3-step pipeline

1 POST /skills/extract-from-jd

2 POST /skills/extract-details

3 POST /skills/final-role-output

Role Chosen role & resolution

Frontend Developer

Angular Frontend Developer

sub-role · 0.90 domain · Software Engineering CASE DOMAIN

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

Domain=Software Engineering → sub-role angular-frontend-developer; The JD is for a Frontend Product Development Engineer requiring hands-on web UI development with JavaScript, AngularJS/React, responsive CSS, and front-end engineering practices.

Matched skills

JavaScriptAngular JS/React JSMongo DBSemantic HTML5Responsive Cross-Platform CSSOOP JavaScriptBootstrap & Responsive Web DesignAngularJS 1.xGruntYeomanLESSSASSAJAXREST and JSONTest-Driven DevelopmentContinuous IntegrationScrum

Matched dimensions

Frontend Web Application DevelopmentUI Markup & Responsive StylingJavaScript Architecture and OOPFront-end Build/Tooling (Grunt, Yeoman)API Communication and Data FormatsQuality Engineering (TDD, CI)Agile Delivery (Scrum/Agile)

Matched KRAs

Distill business objectives into technical solutions through effective system design and architectureWork independently on a project-by project basisProvide technical and analytical solutions to evaluate the merits and challenges of a product ideaDevelop web front end apps using AngularJS 1.x, Grunt, YeomanUse LESS, SASS, AJAX, REST and JSONUse Test-Driven Development and Continuous IntegrationWork in an Agile environment with regular team activitiesWork closely with product owners and designersApply UI/UX principles with attention to detailContribute to open-source projects (a plus)

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

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

Job description

Job Requirements


Experience in software development, product development organization experience preferred.
Be able to distill business objectives into technical solutions through effective system design and architecture
Be able to work independently on a project-by project basis and also work in a collaborative and fast-paced team environment
Be able to provide technical and analytical solutions to evaluate the merits and challenges of a product idea




Work Experience


4-9 years of Software Development experience Strong in JavaScript, Angular JS/React JS, Mongo DB
Strong Knowledge and proven experience of Semantic HTML5 and Responsive Cross-Platform CSS
Knowledge of OOP JavaScript
Experience in Bootstrap & Responsive Web Design
Hands-on coding experience mandatory
Solid written and verbal communication skills
Experience in developing web front end apps using AngularJS 1.x, Grunt, Yeoman, etc.
Good experience with LESS, SASS, AJAX, REST and JSON
Experience with development practices such as Test-Driven Development and Continuous Integration
Experience with Agile development methodologies such as Scrum, or at a minimum, a passion to work in an agile environment.
Software engineering practices and knowledge of Design Patterns
Able to thrive in a fast-paced environment
Work in an Agile environment with regular team activities
Working closely with product owners and designers.
Eye for design aesthetics and attention to detail with a good understanding of UI/UX principles
All around team player and self-learning individual
Contributor to open-source projects – a plus




Benefits


You will get to work with best in industry class of people
You will get to learn latest cutting edge technologies in market
You will get to work in a fast paced environment
You will get to experience our culture, growth and success
You have an opportunity to join our phenomenal family!




If interested please share the updated resume and upload your details:
https://careers.phenompeople.com/us/en/job/P-102225/Product-Development-Engineer-II-Frontend

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

  • 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 saved
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 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)
AngularJS 1.x Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: AngularJS id=1969 · angularjs

Aliases — catalog

  • AngularJS (VERSION)
  • AngularJS 1 (VERSION)
  • AngularJS 1.x (VERSION)

Context tags (catalog)

Angular CLI Angular Material RESTful API RxJS TypeScript component-based dependency injection directive ngRx observable routing service single-page application two-way data binding unit testing

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Web Framework
Vendor
Google
License
mit
Year introduced
2010
Confidence
0.98
Version strategy
SEPARATE_ENTITY
Version tag
1.x

Maturity reasoning: AngularJS 1.x is superseded by Angular; Google ended LTS in 2022 and new job postings overwhelmingly ask for Angular/React instead of AngularJS.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Web UI & Integration Frameworks Catalog dimension db id 268

    Library dimension (catalog)

    Roles linked in library: Pega Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Web UI & Integration Frameworks
web-ui-integration-frameworks
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

  • 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, Hybrid Mobile Developer, Ionic Developer, Web Developer

API 3 link attempts (this skill)

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

Aliases — catalog

  • MongoDB (CANONICAL) primary
  • MongoDB 2.0 (VERSION)
  • MongoDB 2.2 (VERSION)
  • MongoDB 2.4 (VERSION)
  • MongoDB 2.6 (VERSION)
  • MongoDB 3.0 (VERSION)
  • MongoDB 3.2 (VERSION)
  • MongoDB 3.4 (VERSION)
  • MongoDB 3.6 (VERSION)
  • MongoDB 4 (VERSION)
  • MongoDB 4.0 (VERSION)
  • MongoDB 4.2 (VERSION)
  • MongoDB 4.4 (VERSION)
  • MongoDB 5 (VERSION)
  • MongoDB 5.0 (VERSION)
  • MongoDB 6 (VERSION)
  • MongoDB 6.0 (VERSION)
  • MongoDB 7 (VERSION)
  • MongoDB 7.0 (VERSION)
  • MongoDB 8 (VERSION)
  • MongoDB 8.0 (VERSION)

Context tags (catalog)

BSON CRUD GridFS MongoDB Atlas Mongoose NoSQL TTL index aggregation pipeline change streams collections documents indexes replica set sharding

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Document Database
Vendor
MongoDB, Inc.
License
other_open
Year introduced
2009
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
8.0

Maturity reasoning: MongoDB appears in many job descriptions across backend/data roles and is a standard document database in modern stacks; strong GitHub/community activity and broad cloud vendor support indicate mainstream adoption.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
3
Sub-category id
27
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
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML5 Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: HTML5 id=3087 · html5

Aliases — catalog

  • HTML5 (CANONICAL) primary

Context tags (catalog)

Accessibility Audio API Canvas Cross-browser Compatibility DOM Manipulation Geolocation Local Storage Microdata Progressive Web Apps Responsive Design SVG Semantic Elements Video API Web Storage Web Workers

Stored enrichment (catalog DB)

Category
Language
Sub-category
Markup Language
Vendor
W3C
License
unknown
Year introduced
2014
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: HTML5 is a default requirement in web developer JDs and underpins modern browser support; MDN/WHATWG continue active standardization, with no successor replacing it.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Web Standards & Compliance Catalog dimension db id 343

    Library dimension (catalog)

    Roles linked in library: WordPress Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Web Standards & Compliance
web-standards-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: CSS id=623 · css

Aliases — catalog

  • CSS (CANONICAL) primary

Context tags (catalog)

Animations BEM Bootstrap Box Model CSS Modules CSS Variables Flexbox Frameworks Grid LESS Less Media Queries Positioning PostCSS Preprocessors Pseudo-classes Responsive Design SCSS SMACSS Sass Selectors Styling Tailwind CSS Transitions Z-index animation media queries pseudo-elements responsive design styled-components

Stored enrichment (catalog DB)

Category
Language
Sub-category
Stylesheet Language
Vendor
W3C
License
unknown
Year introduced
1996
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: CSS is a core front-end skill in most web JDs and remains standard in MDN/browser docs; it’s broadly used alongside HTML/JS rather than being replaced by a successor.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • CSS Architecture and Styling Catalog dimension db id 117

    Library dimension (catalog)

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

  • 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 Styling and Responsive Layout Catalog dimension db id 423

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

  • Styling and Responsive Layout Catalog dimension db id 307

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CSS Architecture and Styling
css-architecture-and-styling
Existing dimension (library) · Role↔dimension saved
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 Styling and Responsive Layout
storefront-styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Styling and Responsive Layout
styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Bootstrap Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Bootstrap id=1970 · bootstrap

Aliases — catalog

  • Bootstrap (CANONICAL) primary
  • bootstrap 4 (VERSION)
  • bootstrap 5 (VERSION)
  • bootstrap 5.x (VERSION)
  • bootstrap v4 (VERSION)
  • bootstrap v5 (VERSION)
  • bootstrap4 (VERSION)
  • bootstrap5 (VERSION)
  • bs4 (VERSION)
  • bs5 (VERSION)

Context tags (catalog)

CSS CSS framework JavaScript JavaScript plugins Sass accessibility browser compatibility components custom themes flexbox form controls grid system jQuery layout media queries mobile-first modals navbar responsive design utilities utility classes

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Ui Framework
Vendor
Twitter
License
mit
Year introduced
2011
Confidence
0.95
Version strategy
SEPARATE_ENTITY
Version tag
5

Maturity reasoning: Bootstrap remains widely listed in job descriptions for front-end and full-stack roles, especially for rapid UI delivery and legacy maintenance; its GitHub repo and CDN usage stay high despite newer CSS frameworks.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Component Libraries and Design Systems Catalog dimension db id 118

    Library dimension (catalog)

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

  • Web UI & Integration Frameworks Catalog dimension db id 268

    Library dimension (catalog)

    Roles linked in library: Pega Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Component Libraries and Design Systems
component-libraries-and-design-systems
Existing dimension (library) · Role↔dimension saved
Web UI & Integration Frameworks
web-ui-integration-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
LESS 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
Web Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Sass Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Sass id=624 · sass

Aliases — catalog

  • Sass (CANONICAL) primary

Context tags (catalog)

@extend @import @mixin BEM CSS CSS modules CSS preprocessors Less PostCSS SCSS autoprefixer compass compilation design system frameworks functions inheritance media queries mixins modular CSS nesting partials responsive design stylelint styles stylesheets variables

Stored enrichment (catalog DB)

Category
Language
Sub-category
Stylesheet Language
Vendor
Hampton Catlin
License
mit
Year introduced
2006
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Sass still appears in many front-end job descriptions and is widely supported in build tools, though CSS custom properties have reduced some greenfield demand.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • CSS Architecture and Styling Catalog dimension db id 117

    Library dimension (catalog)

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

  • Storefront Styling and Responsive Layout Catalog dimension db id 423

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CSS Architecture and Styling
css-architecture-and-styling
Existing dimension (library) · Role↔dimension saved
Storefront Styling and Responsive Layout
storefront-styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AJAX 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
Web Frameworks
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
REST Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: REST id=11 · rest

Aliases — catalog

  • REST (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • API Design and Contracts Catalog dimension db id 3

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • API Interface and Contract Design Catalog dimension db id 289

    Library dimension (catalog)

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

  • Integration Protocols & Standards Catalog dimension db id 271

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Standards & Protocols Compliance Catalog dimension db id 452

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

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

Aliases — catalog

  • JSON (CANONICAL) primary

Context tags (catalog)

AJAX API JSON Schema JSON-LD JSONP JavaScript NoSQL REST configuration data binding data format data interchange data structure deserialization interoperability key-value pairs lightweight object notation schema serialization text-based

Stored enrichment (catalog DB)

Category
Format
Sub-category
Data Interchange Format
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: JSON is a default data interchange format in APIs and web stacks; it appears in a very high volume of job descriptions and is supported by every major language/runtime.

Skill profile (library / DB)

Skill nature
STANDARD
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
4
Sub-category id
1457
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • API Integration and Data Fetching Catalog dimension db id 127

    Library dimension (catalog)

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

  • API 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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
API Integration and Data Fetching
api-integration-and-data-fetching
Existing dimension (library) · Role↔dimension saved
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)
Test-Driven Development 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
Soft Skills
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Continuous Integration 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
Soft Skills
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Agile Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Agile id=520 · agile

Aliases — catalog

  • Agile (CANONICAL) primary

Context tags (catalog)

Kanban SAFe Scrum backlog backlog grooming burndown burndown chart continuous delivery continuous improvement cross-functional daily standup epics incremental development iteration iteration planning lean product backlog product owner retrospective sprint sprint planning stand-up story points user stories velocity

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Agile
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Agile appears in a large share of software job descriptions and is a standard hiring-pipeline requirement; Scrum/Kanban are commonly listed alongside it, showing broad market adoption.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
367
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)
Scrum Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Scrum id=1215 · scrum

Aliases — catalog

  • Scrum (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Scrum
Confidence
0.99
Version strategy
NOT_APPLICABLE

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Grunt 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
DevOps Tools
Sub-category
general
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
Yeoman 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
DevOps Tools
Sub-category
general
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
OOP JavaScript 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
Programming Languages
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 saved
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 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)
AngularJS 1.x in_db
Web UI & Integration Frameworks
web-ui-integration-frameworks
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
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
MongoDB in_db
NoSQL Databases
nosql-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML5 in_db
Web Standards & Compliance
web-standards-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
CSS Architecture and Styling
css-architecture-and-styling
Existing dimension (library) · Role↔dimension saved
CSS in_db
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
Storefront Styling and Responsive Layout
storefront-styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
Styling and Responsive Layout
styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Bootstrap in_db
Component Libraries and Design Systems
component-libraries-and-design-systems
Existing dimension (library) · Role↔dimension saved
Bootstrap in_db
Web UI & Integration Frameworks
web-ui-integration-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sass in_db
CSS Architecture and Styling
css-architecture-and-styling
Existing dimension (library) · Role↔dimension saved
Sass in_db
Storefront Styling and Responsive Layout
storefront-styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
API Design and Contracts
api-design-and-contracts
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
API Interface and Contract Design
api-interface-and-contract-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
Standards & Protocols Compliance
standards-protocols-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JSON in_db
API Integration and Data Fetching
api-integration-and-data-fetching
Existing dimension (library) · Role↔dimension saved
JSON in_db
API Interface and Contract Design
api-interface-and-contract-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JSON in_db
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agile in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Scrum in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed LESS | type=Web Frameworks subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed AJAX | type=Web Frameworks subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed Test-Driven Development | type=Soft Skills subtype=general nature=PRACTICE lifespan=MULTI_YEAR
canonical_skill_proposed Continuous Integration | type=Soft Skills subtype=general nature=PRACTICE lifespan=MULTI_YEAR
canonical_skill_proposed Grunt | type=DevOps Tools subtype=general nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed Yeoman | type=DevOps Tools subtype=general nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed OOP JavaScript | type=Programming Languages subtype=general nature=CONCEPT lifespan=MULTI_YEAR
nano JD Parser — gpt-4.1-nano click to toggle
RoleProduct Development Engineer II - Frontend
Experience4-9 years of Software Development experience
DomainSoftware & SaaS Products
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": null,
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [
        "SaaS",
        "Product Companies"
      ],
      "domain": "Software \u0026 SaaS Products"
    },
    "secondary": null
  },
  "education": [],
  "experience": {
    "max": 9,
    "min": 4,
    "raw": "4-9 years of Software Development experience"
  },
  "job_locations": [],
  "role": "Product Development Engineer II - Frontend",
  "role_aliases": [
    "Frontend Engineer",
    "Frontend Developer",
    "Software Engineer"
  ],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 4,
      "heading": "Job Requirements",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Experience in software development, product",
        "last_5_words": "merits and challenges of a product idea"
      },
      "text": "Experience in software development, product development organization experience preferred.\nBe able to distill business objectives into technical solutions through effective system design and architecture\nBe able to work independently on a project-by project basis and also work in a collaborative and fast-paced team environment\nBe able to provide technical and analytical solutions to evaluate the merits and challenges of a product idea",
      "word_count": 52
    },
    {
      "bullet_count": 15,
      "heading": "Work Experience",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "4-9 years of Software Development",
        "last_5_words": "open-source projects \u2013 a plus"
      },
      "text": "4-9 years of Software Development experience Strong in JavaScript, Angular JS/React JS, Mongo DB\nStrong Knowledge and proven experience of Semantic HTML5 and Responsive Cross-Platform CSS\nKnowledge of OOP JavaScript\nExperience in Bootstrap \u0026 Responsive Web Design\nHands-on coding experience mandatory\nSolid written and verbal communication skills\nExperience in developing web front end apps using AngularJS 1.x, Grunt, Yeoman, etc.\nGood experience with LESS, SASS, AJAX, REST and JSON\nExperience with development practices such as Test-Driven Development and Continuous Integration\nExperience with Agile development methodologies such as Scrum, or at a minimum, a passion to work in an agile environment.\nSoftware engineering practices and knowledge of Design Patterns\nAble to thrive in a fast-paced environment\nWork in an Agile environment with regular team activities\nWorking closely with product owners and designers.\nEye for design aesthetics and attention to detail with a good understanding of UI/UX principles\nAll around team player and self-learning individual\nContributor to open-source projects \u2013 a plus",
      "word_count": 218
    }
  ],
  "urls": [
    {
      "type": "careers",
      "url": "https://careers.phenompeople.com/us/en/job/P-102225/Product-Development-Engineer-II-Frontend"
    }
  ]
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "JavaScript"
    },
    {
      "is_primary": true,
      "skill_name": "AngularJS 1.x"
    },
    {
      "is_primary": true,
      "skill_name": "React"
    },
    {
      "is_primary": true,
      "skill_name": "MongoDB"
    },
    {
      "is_primary": true,
      "skill_name": "HTML5"
    },
    {
      "is_primary": true,
      "skill_name": "CSS"
    },
    {
      "is_primary": false,
      "skill_name": "Bootstrap"
    },
    {
      "is_primary": false,
      "skill_name": "LESS"
    },
    {
      "is_primary": false,
      "skill_name": "Sass"
    },
    {
      "is_primary": false,
      "skill_name": "AJAX"
    },
    {
      "is_primary": false,
      "skill_name": "REST"
    },
    {
      "is_primary": false,
      "skill_name": "JSON"
    },
    {
      "is_primary": false,
      "skill_name": "Test-Driven Development"
    },
    {
      "is_primary": false,
      "skill_name": "Continuous Integration"
    },
    {
      "is_primary": false,
      "skill_name": "Agile"
    },
    {
      "is_primary": false,
      "skill_name": "Scrum"
    },
    {
      "is_primary": false,
      "skill_name": "Grunt"
    },
    {
      "is_primary": false,
      "skill_name": "Yeoman"
    },
    {
      "is_primary": false,
      "skill_name": "OOP JavaScript"
    }
  ],
  "jd_role": {
    "display_name": "Product Development Engineer II - Frontend",
    "rationale": null,
    "role_aliases": [
      "Frontend Engineer",
      "Frontend Developer",
      "Software Engineer"
    ],
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": null,
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [
          "SaaS",
          "Product Companies"
        ],
        "domain": "Software \u0026 SaaS Products"
      },
      "secondary": null
    },
    "education": [],
    "experience": {
      "max": 9,
      "min": 4,
      "raw": "4-9 years of Software Development experience"
    },
    "job_locations": [],
    "role": "Product Development Engineer II - Frontend",
    "role_aliases": [
      "Frontend Engineer",
      "Frontend Developer",
      "Software Engineer"
    ],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 4,
        "heading": "Job Requirements",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Experience in software development, product",
          "last_5_words": "merits and challenges of a product idea"
        },
        "text": "Experience in software development, product development organization experience preferred.\nBe able to distill business objectives into technical solutions through effective system design and architecture\nBe able to work independently on a project-by project basis and also work in a collaborative and fast-paced team environment\nBe able to provide technical and analytical solutions to evaluate the merits and challenges of a product idea",
        "word_count": 52
      },
      {
        "bullet_count": 15,
        "heading": "Work Experience",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "4-9 years of Software Development",
          "last_5_words": "open-source projects \u2013 a plus"
        },
        "text": "4-9 years of Software Development experience Strong in JavaScript, Angular JS/React JS, Mongo DB\nStrong Knowledge and proven experience of Semantic HTML5 and Responsive Cross-Platform CSS\nKnowledge of OOP JavaScript\nExperience in Bootstrap \u0026 Responsive Web Design\nHands-on coding experience mandatory\nSolid written and verbal communication skills\nExperience in developing web front end apps using AngularJS 1.x, Grunt, Yeoman, etc.\nGood experience with LESS, SASS, AJAX, REST and JSON\nExperience with development practices such as Test-Driven Development and Continuous Integration\nExperience with Agile development methodologies such as Scrum, or at a minimum, a passion to work in an agile environment.\nSoftware engineering practices and knowledge of Design Patterns\nAble to thrive in a fast-paced environment\nWork in an Agile environment with regular team activities\nWorking closely with product owners and designers.\nEye for design aesthetics and attention to detail with a good understanding of UI/UX principles\nAll around team player and self-learning individual\nContributor to open-source projects \u2013 a plus",
        "word_count": 218
      }
    ],
    "urls": [
      {
        "type": "careers",
        "url": "https://careers.phenompeople.com/us/en/job/P-102225/Product-Development-Engineer-II-Frontend"
      }
    ]
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "90a79cd7-55d4-4b8a-a17e-93346336ae76",
  "stage3_signals": {
    "alias_found": true,
    "alias_match_roles": [
      {
        "display_name": "Web Developer",
        "kra_matches": null,
        "matched_count": null,
        "matched_skills": null,
        "role_id": 25,
        "score": 1.0,
        "slug": "web-developer",
        "total_count": null
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": null,
        "matched_count": null,
        "matched_skills": null,
        "role_id": 7,
        "score": 1.0,
        "slug": "frontend-engineer",
        "total_count": null
      }
    ],
    "kra_match_roles": [
      {
        "display_name": "Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "Collaborates with UX designers to refine interaction details, animations, responsive breakpoints, and micro-interaction behavior.",
            "sentence": "Working closely with product owners and designers.",
            "similarity": 0.6271
          },
          {
            "kra_text": "Collaborates with UX designers to refine interaction details, animations, responsive breakpoints, and micro-interaction behavior.",
            "sentence": "Eye for design aesthetics and attention to detail with a good understanding of UI/UX principles",
            "similarity": 0.5801
          },
          {
            "kra_text": "Ensures WCAG accessibility compliance by implementing semantic HTML, ARIA attributes, keyboard navigation, and screen reader compatibility.",
            "sentence": "Strong Knowledge and proven experience of Semantic HTML5 and Responsive Cross-Platform CSS",
            "similarity": 0.5622
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 7,
        "score": 0.5898,
        "slug": "frontend-engineer",
        "total_count": null
      },
      {
        "display_name": "Fullstack Developer",
        "kra_matches": [
          {
            "kra_text": "Works closely with product managers and UX designers to translate requirements and wireframes into working software features through iterative development.",
            "sentence": "Working closely with product owners and designers.",
            "similarity": 0.7395
          },
          {
            "kra_text": "Works closely with product managers and UX designers to translate requirements and wireframes into working software features through iterative development.",
            "sentence": "Eye for design aesthetics and attention to detail with a good understanding of UI/UX principles",
            "similarity": 0.4888
          },
          {
            "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": "4-9 years of Software Development experience Strong in JavaScript, Angular JS/React JS, Mongo DB",
            "similarity": 0.4676
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 15,
        "score": 0.5653,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Angular Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "collaboration with design and QA",
            "sentence": "Working closely with product owners and designers.",
            "similarity": 0.6005
          },
          {
            "kra_text": "UI responsiveness and performance",
            "sentence": "Strong Knowledge and proven experience of Semantic HTML5 and Responsive Cross-Platform CSS",
            "similarity": 0.5205
          },
          {
            "kra_text": "UI responsiveness and performance",
            "sentence": "Eye for design aesthetics and attention to detail with a good understanding of UI/UX principles",
            "similarity": 0.4973
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 90,
        "score": 0.5394,
        "slug": "angular-frontend-developer",
        "total_count": null
      },
      {
        "display_name": "Flutter Developer",
        "kra_matches": [
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Working closely with product owners and designers.",
            "similarity": 0.6626
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Be able to work independently on a project-by project basis and also work in a collaborative and fast-paced team environment",
            "similarity": 0.4722
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Be able to distill business objectives into technical solutions through effective system design and architecture",
            "similarity": 0.4601
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 74,
        "score": 0.5316,
        "slug": "flutter-developer",
        "total_count": null
      },
      {
        "display_name": "Pega Developer",
        "kra_matches": [
          {
            "kra_text": "user interaction design and refinement",
            "sentence": "Eye for design aesthetics and attention to detail with a good understanding of UI/UX principles",
            "similarity": 0.6025
          },
          {
            "kra_text": "user interaction design and refinement",
            "sentence": "Working closely with product owners and designers.",
            "similarity": 0.5081
          },
          {
            "kra_text": "Requirements analysis and process translation",
            "sentence": "Be able to distill business objectives into technical solutions through effective system design and architecture",
            "similarity": 0.4615
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 24,
        "score": 0.524,
        "slug": "pega-developer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "CSS",
          "JavaScript",
          "React"
        ],
        "role_id": 15,
        "score": 0.5,
        "slug": "full-stack-engineer",
        "total_count": 6
      },
      {
        "display_name": "Web Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "CSS",
          "JavaScript",
          "React"
        ],
        "role_id": 25,
        "score": 0.5,
        "slug": "web-developer",
        "total_count": 6
      },
      {
        "display_name": "React Frontend Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "CSS",
          "JavaScript",
          "React"
        ],
        "role_id": 89,
        "score": 0.5,
        "slug": "react-frontend-developer",
        "total_count": 6
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "CSS",
          "JavaScript",
          "React"
        ],
        "role_id": 7,
        "score": 0.5,
        "slug": "frontend-engineer",
        "total_count": 6
      },
      {
        "display_name": "WordPress Dev",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "HTML5",
          "JavaScript",
          "React"
        ],
        "role_id": 227,
        "score": 0.5,
        "slug": "wordpress-dev",
        "total_count": 6
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "DOMAIN",
    "chosen_role": {
      "display_name": "Frontend Developer",
      "kra_matches": null,
      "matched_count": null,
      "matched_skills": null,
      "role_id": 7,
      "score": 0.95,
      "slug": "frontend-engineer",
      "total_count": null
    },
    "confidence": 0.95,
    "is_new_role": false,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "matched_dimensions": [
      "Frontend Web Application Development",
      "UI Markup \u0026 Responsive Styling",
      "JavaScript Architecture and OOP",
      "Front-end Build/Tooling (Grunt, Yeoman)",
      "API Communication and Data Formats",
      "Quality Engineering (TDD, CI)",
      "Agile Delivery (Scrum/Agile)"
    ],
    "matched_kras": [
      "Distill business objectives into technical solutions through effective system design and architecture",
      "Work independently on a project-by project basis",
      "Provide technical and analytical solutions to evaluate the merits and challenges of a product idea",
      "Develop web front end apps using AngularJS 1.x, Grunt, Yeoman",
      "Use LESS, SASS, AJAX, REST and JSON",
      "Use Test-Driven Development and Continuous Integration",
      "Work in an Agile environment with regular team activities",
      "Work closely with product owners and designers",
      "Apply UI/UX principles with attention to detail",
      "Contribute to open-source projects (a plus)"
    ],
    "matched_skills": [
      "JavaScript",
      "Angular JS/React JS",
      "Mongo DB",
      "Semantic HTML5",
      "Responsive Cross-Platform CSS",
      "OOP JavaScript",
      "Bootstrap \u0026 Responsive Web Design",
      "AngularJS 1.x",
      "Grunt",
      "Yeoman",
      "LESS",
      "SASS",
      "AJAX",
      "REST and JSON",
      "Test-Driven Development",
      "Continuous Integration",
      "Scrum"
    ],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "Domain=Software Engineering \u2192 sub-role angular-frontend-developer; The JD is for a Frontend Product Development Engineer requiring hands-on web UI development with JavaScript, AngularJS/React, responsive CSS, and front-end engineering practices.",
    "sub_role": {
      "confidence": 0.9,
      "display_name": "Angular Frontend Developer",
      "reasoning": "The JD explicitly requires AngularJS 1.x and related tooling (Grunt, Yeoman) alongside strong JavaScript/CSS skills, with no similar emphasis on React/Vue/Svelte.",
      "role_id": 90,
      "slug": "angular-frontend-developer"
    }
  },
  "stage5_updates": {
    "centroid_n_after": 55,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": null,
    "new_skills_attached": [
      {
        "is_primary": false,
        "queue_id": 3751,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "LESS",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3752,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "AJAX",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3753,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "Test-Driven Development",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3754,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "Continuous Integration",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3755,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "Grunt",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3756,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "Yeoman",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3757,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "OOP JavaScript",
        "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": 2990,
      "existing_alias_text": "AngularJS 1.x",
      "input_term": "AngularJS 1.x",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "AngularJS",
        "id": 1969,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "angularjs",
        "sub_category_id": 35,
        "typical_lifespan": "EVERGREEN",
        "volatility": "DEPRECATED"
      },
      "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": 232,
      "existing_alias_text": "MongoDB",
      "input_term": "MongoDB",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "MongoDB",
        "id": 91,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mongodb",
        "sub_category_id": 27,
        "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": 4554,
      "existing_alias_text": "HTML5",
      "input_term": "HTML5",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "HTML5",
        "id": 3087,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "html5",
        "sub_category_id": 1467,
        "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": 1107,
      "existing_alias_text": "CSS",
      "input_term": "CSS",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "CSS",
        "id": 623,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "css",
        "sub_category_id": 486,
        "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": 2991,
      "existing_alias_text": "Bootstrap",
      "input_term": "Bootstrap",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Bootstrap",
        "id": 1970,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "bootstrap",
        "sub_category_id": 341,
        "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": 1108,
      "existing_alias_text": "Sass",
      "input_term": "Sass",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Sass",
        "id": 624,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "sass",
        "sub_category_id": 486,
        "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": 3018,
      "existing_alias_text": "JSON",
      "input_term": "JSON",
      "matched_canonical": {
        "category_id": 4,
        "display_name": "JSON",
        "id": 1984,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "STANDARD",
        "slug": "json",
        "sub_category_id": 1457,
        "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": 868,
      "existing_alias_text": "Agile",
      "input_term": "Agile",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Agile",
        "id": 520,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "agile",
        "sub_category_id": 367,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1851,
      "existing_alias_text": "Scrum",
      "input_term": "Scrum",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Scrum",
        "id": 1215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "scrum",
        "sub_category_id": 921,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "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": "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": ".NET Backend Developer",
      "id": 83,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "dotnet-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Go Backend Developer",
      "id": 81,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "go-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Kotlin Backend Developer",
      "id": 84,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "kotlin-server-backend-developer",
      "source": "db"
    },
    {
      "display_name": "PHP Backend Developer",
      "id": 86,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "php-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Python Backend Developer",
      "id": 80,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "python-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Ruby Backend Developer",
      "id": 85,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "ruby-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Scala Backend Developer",
      "id": 87,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "scala-backend-developer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Frontend Developer",
    "id": 7,
    "rationale": "Domain=Software Engineering \u2192 sub-role angular-frontend-developer; The JD is for a Frontend Product Development Engineer requiring hands-on web UI development with JavaScript, AngularJS/React, responsive CSS, and front-end engineering practices.",
    "role_archetype": null,
    "slug": "frontend-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"
        }
      ]
    },
    {
      "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": "Web UI \u0026 Integration Frameworks",
        "id": 268,
        "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
        "slug": "web-ui-integration-frameworks",
        "source": "db"
      },
      "input_skill": "AngularJS 1.x",
      "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": "Application Frameworks \u0026 Libraries",
        "id": 451,
        "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
        "slug": "application-frameworks-libraries",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Frameworks and Libraries",
        "id": 434,
        "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
        "slug": "frontend-frameworks-and-libraries",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "JavaScript for WordPress",
        "id": 329,
        "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
        "slug": "javascript-for-wordpress",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "WordPress Dev",
          "id": 227,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "wordpress-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Component Architecture",
        "id": 302,
        "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
        "slug": "react-component-architecture",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "NoSQL Databases",
        "id": 19,
        "rationale": "Models and manages data using non-relational database systems.",
        "slug": "nosql-databases",
        "source": "db"
      },
      "input_skill": "MongoDB",
      "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": "Web Standards \u0026 Compliance",
        "id": 343,
        "rationale": "Ensuring WordPress sites adhere to web markup, styling, accessibility, and privacy regulations.",
        "slug": "web-standards-compliance",
        "source": "db"
      },
      "input_skill": "HTML5",
      "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": "CSS Architecture and Styling",
        "id": 117,
        "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
        "slug": "css-architecture-and-styling",
        "source": "db"
      },
      "input_skill": "CSS",
      "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": "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": "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": "CSS",
      "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": "CSS",
      "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 Styling and Responsive Layout",
        "id": 423,
        "rationale": "Visual presentation work for Shopify storefronts, including layout, spacing, typography, and responsive behavior. This is a coherent cluster because theme developers must translate commerce designs into usable storefront pages.",
        "slug": "storefront-styling-and-responsive-layout",
        "source": "db"
      },
      "input_skill": "CSS",
      "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": "Styling and Responsive Layout",
        "id": 307,
        "rationale": "Visual presentation techniques used to translate design requirements into usable Angular interfaces. This includes layout, theming, spacing, and responsive behavior across screen sizes.",
        "slug": "styling-and-responsive-layout",
        "source": "db"
      },
      "input_skill": "CSS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Component Libraries and Design Systems",
        "id": 118,
        "rationale": "Reusable UI kits and design-system implementations that standardize look, feel, and interaction patterns across products. This is a distinct cluster because frontend engineers frequently consume and extend these libraries.",
        "slug": "component-libraries-and-design-systems",
        "source": "db"
      },
      "input_skill": "Bootstrap",
      "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": "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": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web UI \u0026 Integration Frameworks",
        "id": 268,
        "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
        "slug": "web-ui-integration-frameworks",
        "source": "db"
      },
      "input_skill": "Bootstrap",
      "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": "CSS Architecture and Styling",
        "id": 117,
        "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
        "slug": "css-architecture-and-styling",
        "source": "db"
      },
      "input_skill": "Sass",
      "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": "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": "Storefront Styling and Responsive Layout",
        "id": 423,
        "rationale": "Visual presentation work for Shopify storefronts, including layout, spacing, typography, and responsive behavior. This is a coherent cluster because theme developers must translate commerce designs into usable storefront pages.",
        "slug": "storefront-styling-and-responsive-layout",
        "source": "db"
      },
      "input_skill": "Sass",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Design and Contracts",
        "id": 3,
        "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
        "slug": "api-design-and-contracts",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Interface and Contract Design",
        "id": 289,
        "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
        "slug": "api-interface-and-contract-design",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Integration Protocols \u0026 Standards",
        "id": 271,
        "rationale": "Standards and protocols for integrating Pega applications.",
        "slug": "integration-protocols-standards",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Standards \u0026 Protocols Compliance",
        "id": 452,
        "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
        "slug": "standards-protocols-compliance",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "JSON",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Interface and Contract Design",
        "id": 289,
        "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
        "slug": "api-interface-and-contract-design",
        "source": "db"
      },
      "input_skill": "JSON",
      "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": "JSON",
      "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": "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": "Agile",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Scrum",
      "llm_role": null,
      "roles_from_db": []
    }
  ],
  "input_final_skills": [
    "JavaScript",
    "AngularJS 1.x",
    "React",
    "MongoDB",
    "HTML5",
    "CSS",
    "Bootstrap",
    "LESS",
    "Sass",
    "AJAX",
    "REST",
    "JSON",
    "Test-Driven Development",
    "Continuous Integration",
    "Agile",
    "Scrum",
    "Grunt",
    "Yeoman",
    "OOP JavaScript"
  ],
  "input_llm_skills": [
    "JavaScript",
    "AngularJS 1.x",
    "React",
    "MongoDB",
    "HTML5",
    "CSS",
    "Bootstrap",
    "LESS",
    "Sass",
    "AJAX",
    "REST",
    "JSON",
    "Test-Driven Development",
    "Continuous Integration",
    "Agile",
    "Scrum",
    "Grunt",
    "Yeoman",
    "OOP JavaScript"
  ],
  "new_aliases_persisted": 0,
  "run_id": "90a79cd7-55d4-4b8a-a17e-93346336ae76",
  "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"
            }
          ]
        },
        {
          "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": "AngularJS",
          "alias_type": "VERSION",
          "id": 2987,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "AngularJS 1",
          "alias_type": "VERSION",
          "id": 2989,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "AngularJS 1.x",
          "alias_type": "VERSION",
          "id": 2990,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "AngularJS",
        "id": 1969,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "angularjs",
        "sub_category_id": 35,
        "typical_lifespan": "EVERGREEN",
        "volatility": "DEPRECATED"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web UI \u0026 Integration Frameworks",
            "id": 268,
            "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
            "slug": "web-ui-integration-frameworks",
            "source": "db"
          },
          "input_skill": "AngularJS 1.x",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AngularJS 1.x",
      "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": "ReactJS 18",
          "alias_type": "VERSION",
          "id": 2074,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 15",
          "alias_type": "VERSION",
          "id": 2069,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 16",
          "alias_type": "VERSION",
          "id": 2070,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 17",
          "alias_type": "VERSION",
          "id": 2071,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 18",
          "alias_type": "VERSION",
          "id": 2072,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 19",
          "alias_type": "VERSION",
          "id": 2073,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react15",
          "alias_type": "VERSION",
          "id": 3177,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react16",
          "alias_type": "VERSION",
          "id": 3178,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react17",
          "alias_type": "VERSION",
          "id": 3179,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react18",
          "alias_type": "VERSION",
          "id": 3180,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "reactjs 18",
          "alias_type": "VERSION",
          "id": 2075,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "React",
        "id": 610,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Application Frameworks \u0026 Libraries",
            "id": 451,
            "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
            "slug": "application-frameworks-libraries",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Frameworks and Libraries",
            "id": 434,
            "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
            "slug": "frontend-frameworks-and-libraries",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript for WordPress",
            "id": 329,
            "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
            "slug": "javascript-for-wordpress",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "WordPress Dev",
              "id": 227,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "wordpress-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Component Architecture",
            "id": 302,
            "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
            "slug": "react-component-architecture",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "MongoDB",
          "alias_type": "CANONICAL",
          "id": 232,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.0",
          "alias_type": "VERSION",
          "id": 238,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.2",
          "alias_type": "VERSION",
          "id": 239,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.4",
          "alias_type": "VERSION",
          "id": 240,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.6",
          "alias_type": "VERSION",
          "id": 241,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.0",
          "alias_type": "VERSION",
          "id": 242,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.2",
          "alias_type": "VERSION",
          "id": 243,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.4",
          "alias_type": "VERSION",
          "id": 244,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.6",
          "alias_type": "VERSION",
          "id": 245,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4",
          "alias_type": "VERSION",
          "id": 233,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4.0",
          "alias_type": "VERSION",
          "id": 246,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4.2",
          "alias_type": "VERSION",
          "id": 247,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4.4",
          "alias_type": "VERSION",
          "id": 248,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 5",
          "alias_type": "VERSION",
          "id": 234,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 5.0",
          "alias_type": "VERSION",
          "id": 249,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 6",
          "alias_type": "VERSION",
          "id": 235,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 6.0",
          "alias_type": "VERSION",
          "id": 250,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 7",
          "alias_type": "VERSION",
          "id": 236,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 7.0",
          "alias_type": "VERSION",
          "id": 251,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 8",
          "alias_type": "VERSION",
          "id": 237,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 8.0",
          "alias_type": "VERSION",
          "id": 252,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "MongoDB",
        "id": 91,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mongodb",
        "sub_category_id": 27,
        "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": "MongoDB",
          "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": "MongoDB",
      "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": "HTML5",
          "alias_type": "CANONICAL",
          "id": 4554,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "HTML5",
        "id": 3087,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "html5",
        "sub_category_id": 1467,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web Standards \u0026 Compliance",
            "id": 343,
            "rationale": "Ensuring WordPress sites adhere to web markup, styling, accessibility, and privacy regulations.",
            "slug": "web-standards-compliance",
            "source": "db"
          },
          "input_skill": "HTML5",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "WordPress Dev",
              "id": 227,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "wordpress-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "HTML5",
      "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": "CSS",
          "alias_type": "CANONICAL",
          "id": 1107,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "CSS",
        "id": 623,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "css",
        "sub_category_id": 486,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CSS Architecture and Styling",
            "id": 117,
            "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
            "slug": "css-architecture-and-styling",
            "source": "db"
          },
          "input_skill": "CSS",
          "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": "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": "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": "CSS",
          "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": "CSS",
          "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 Styling and Responsive Layout",
            "id": 423,
            "rationale": "Visual presentation work for Shopify storefronts, including layout, spacing, typography, and responsive behavior. This is a coherent cluster because theme developers must translate commerce designs into usable storefront pages.",
            "slug": "storefront-styling-and-responsive-layout",
            "source": "db"
          },
          "input_skill": "CSS",
          "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": "Styling and Responsive Layout",
            "id": 307,
            "rationale": "Visual presentation techniques used to translate design requirements into usable Angular interfaces. This includes layout, theming, spacing, and responsive behavior across screen sizes.",
            "slug": "styling-and-responsive-layout",
            "source": "db"
          },
          "input_skill": "CSS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "CSS",
      "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": "Bootstrap",
          "alias_type": "CANONICAL",
          "id": 2991,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap 4",
          "alias_type": "VERSION",
          "id": 2996,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap 5",
          "alias_type": "VERSION",
          "id": 2997,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap 5.x",
          "alias_type": "VERSION",
          "id": 3240,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap v4",
          "alias_type": "VERSION",
          "id": 2998,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap v5",
          "alias_type": "VERSION",
          "id": 2999,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap4",
          "alias_type": "VERSION",
          "id": 2994,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap5",
          "alias_type": "VERSION",
          "id": 2995,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bs4",
          "alias_type": "VERSION",
          "id": 2992,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bs5",
          "alias_type": "VERSION",
          "id": 2993,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Bootstrap",
        "id": 1970,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "bootstrap",
        "sub_category_id": 341,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Component Libraries and Design Systems",
            "id": 118,
            "rationale": "Reusable UI kits and design-system implementations that standardize look, feel, and interaction patterns across products. This is a distinct cluster because frontend engineers frequently consume and extend these libraries.",
            "slug": "component-libraries-and-design-systems",
            "source": "db"
          },
          "input_skill": "Bootstrap",
          "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": "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": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web UI \u0026 Integration Frameworks",
            "id": 268,
            "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
            "slug": "web-ui-integration-frameworks",
            "source": "db"
          },
          "input_skill": "Bootstrap",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Bootstrap",
      "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": "LESS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Web Frameworks",
          "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": "less",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Sass",
          "alias_type": "CANONICAL",
          "id": 1108,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Sass",
        "id": 624,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "sass",
        "sub_category_id": 486,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CSS Architecture and Styling",
            "id": 117,
            "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
            "slug": "css-architecture-and-styling",
            "source": "db"
          },
          "input_skill": "Sass",
          "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": "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": "Storefront Styling and Responsive Layout",
            "id": 423,
            "rationale": "Visual presentation work for Shopify storefronts, including layout, spacing, typography, and responsive behavior. This is a coherent cluster because theme developers must translate commerce designs into usable storefront pages.",
            "slug": "storefront-styling-and-responsive-layout",
            "source": "db"
          },
          "input_skill": "Sass",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Sass",
      "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": "AJAX",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Web Frameworks",
          "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": "ajax",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "REST",
          "alias_type": "CANONICAL",
          "id": 106,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "REST",
        "id": 11,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rest",
        "sub_category_id": 2122,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Design and Contracts",
            "id": 3,
            "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
            "slug": "api-design-and-contracts",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Interface and Contract Design",
            "id": 289,
            "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
            "slug": "api-interface-and-contract-design",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Integration Protocols \u0026 Standards",
            "id": 271,
            "rationale": "Standards and protocols for integrating Pega applications.",
            "slug": "integration-protocols-standards",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Standards \u0026 Protocols Compliance",
            "id": 452,
            "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
            "slug": "standards-protocols-compliance",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "REST",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "JSON",
          "alias_type": "CANONICAL",
          "id": 3018,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 4,
        "display_name": "JSON",
        "id": 1984,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "STANDARD",
        "slug": "json",
        "sub_category_id": 1457,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Integration and Data Fetching",
            "id": 127,
            "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
            "slug": "api-integration-and-data-fetching",
            "source": "db"
          },
          "input_skill": "JSON",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Interface and Contract Design",
            "id": 289,
            "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
            "slug": "api-interface-and-contract-design",
            "source": "db"
          },
          "input_skill": "JSON",
          "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": "JSON",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "JSON",
      "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": "Test-Driven Development",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Soft Skills",
          "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": "test-driven-development",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "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": "Soft Skills",
          "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": [
        {
          "alias_text": "Agile",
          "alias_type": "CANONICAL",
          "id": 868,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Agile",
        "id": 520,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "agile",
        "sub_category_id": 367,
        "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": "Agile",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Agile",
      "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": "Scrum",
          "alias_type": "CANONICAL",
          "id": 1851,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Scrum",
        "id": 1215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "scrum",
        "sub_category_id": 921,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Scrum",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Scrum",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Grunt",
      "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": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "grunt",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Yeoman",
      "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": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "yeoman",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "OOP JavaScript",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Programming Languages",
          "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": "oop-javascript",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "LESS",
    "AJAX",
    "Test-Driven Development",
    "Continuous Integration",
    "Grunt",
    "Yeoman",
    "OOP JavaScript"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "Frontend Developer",
    "id": 7,
    "rationale": "Domain=Software Engineering \u2192 sub-role angular-frontend-developer; The JD is for a Frontend Product Development Engineer requiring hands-on web UI development with JavaScript, AngularJS/React, responsive CSS, and front-end engineering practices.",
    "role_archetype": null,
    "slug": "frontend-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "JavaScript",
      "tag": "in_db"
    },
    {
      "skill": "AngularJS 1.x",
      "tag": "in_db"
    },
    {
      "skill": "React",
      "tag": "in_db"
    },
    {
      "skill": "MongoDB",
      "tag": "in_db"
    },
    {
      "skill": "HTML5",
      "tag": "in_db"
    },
    {
      "skill": "CSS",
      "tag": "in_db"
    },
    {
      "skill": "Bootstrap",
      "tag": "in_db"
    },
    {
      "skill": "LESS",
      "tag": "new"
    },
    {
      "skill": "Sass",
      "tag": "in_db"
    },
    {
      "skill": "AJAX",
      "tag": "new"
    },
    {
      "skill": "REST",
      "tag": "in_db"
    },
    {
      "skill": "JSON",
      "tag": "in_db"
    },
    {
      "skill": "Test-Driven Development",
      "tag": "new"
    },
    {
      "skill": "Continuous Integration",
      "tag": "new"
    },
    {
      "skill": "Agile",
      "tag": "in_db"
    },
    {
      "skill": "Scrum",
      "tag": "in_db"
    },
    {
      "skill": "Grunt",
      "tag": "new"
    },
    {
      "skill": "Yeoman",
      "tag": "new"
    },
    {
      "skill": "OOP JavaScript",
      "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": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "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": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "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": "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": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript for WordPress",
          "id": 329,
          "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
          "slug": "javascript-for-wordpress",
          "source": "db"
        },
        "dimension_id": 329,
        "input_skill": "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": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Pega Programming Languages \u0026 DSLs",
          "id": 267,
          "rationale": "Programming languages and domain-specific languages used in Pega development.",
          "slug": "pega-programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 267,
        "input_skill": "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": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "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": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "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": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "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": 7,
        "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": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web UI \u0026 Integration Frameworks",
          "id": 268,
          "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
          "slug": "web-ui-integration-frameworks",
          "source": "db"
        },
        "dimension_id": 268,
        "input_skill": "AngularJS 1.x",
        "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": 1969,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application Frameworks \u0026 Libraries",
          "id": 451,
          "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
          "slug": "application-frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 451,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frontend Frameworks and Libraries",
          "id": 434,
          "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
          "slug": "frontend-frameworks-and-libraries",
          "source": "db"
        },
        "dimension_id": 434,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Shopify Dev",
            "id": 230,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "shopify-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript for WordPress",
          "id": 329,
          "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
          "slug": "javascript-for-wordpress",
          "source": "db"
        },
        "dimension_id": 329,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "WordPress Dev",
            "id": 227,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "wordpress-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Component Architecture",
          "id": 302,
          "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
          "slug": "react-component-architecture",
          "source": "db"
        },
        "dimension_id": 302,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "NoSQL Databases",
          "id": 19,
          "rationale": "Models and manages data using non-relational database systems.",
          "slug": "nosql-databases",
          "source": "db"
        },
        "dimension_id": 19,
        "input_skill": "MongoDB",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 91,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web Standards \u0026 Compliance",
          "id": 343,
          "rationale": "Ensuring WordPress sites adhere to web markup, styling, accessibility, and privacy regulations.",
          "slug": "web-standards-compliance",
          "source": "db"
        },
        "dimension_id": 343,
        "input_skill": "HTML5",
        "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": 3087,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CSS Architecture and Styling",
          "id": 117,
          "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
          "slug": "css-architecture-and-styling",
          "source": "db"
        },
        "dimension_id": 117,
        "input_skill": "CSS",
        "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": "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": 623,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "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": "CSS",
        "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": 623,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "CSS",
        "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": 623,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Storefront Styling and Responsive Layout",
          "id": 423,
          "rationale": "Visual presentation work for Shopify storefronts, including layout, spacing, typography, and responsive behavior. This is a coherent cluster because theme developers must translate commerce designs into usable storefront pages.",
          "slug": "storefront-styling-and-responsive-layout",
          "source": "db"
        },
        "dimension_id": 423,
        "input_skill": "CSS",
        "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": 623,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Styling and Responsive Layout",
          "id": 307,
          "rationale": "Visual presentation techniques used to translate design requirements into usable Angular interfaces. This includes layout, theming, spacing, and responsive behavior across screen sizes.",
          "slug": "styling-and-responsive-layout",
          "source": "db"
        },
        "dimension_id": 307,
        "input_skill": "CSS",
        "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 623,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Component Libraries and Design Systems",
          "id": 118,
          "rationale": "Reusable UI kits and design-system implementations that standardize look, feel, and interaction patterns across products. This is a distinct cluster because frontend engineers frequently consume and extend these libraries.",
          "slug": "component-libraries-and-design-systems",
          "source": "db"
        },
        "dimension_id": 118,
        "input_skill": "Bootstrap",
        "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": "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": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1970,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web UI \u0026 Integration Frameworks",
          "id": 268,
          "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
          "slug": "web-ui-integration-frameworks",
          "source": "db"
        },
        "dimension_id": 268,
        "input_skill": "Bootstrap",
        "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": 1970,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CSS Architecture and Styling",
          "id": 117,
          "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
          "slug": "css-architecture-and-styling",
          "source": "db"
        },
        "dimension_id": 117,
        "input_skill": "Sass",
        "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": "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": 624,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Storefront Styling and Responsive Layout",
          "id": 423,
          "rationale": "Visual presentation work for Shopify storefronts, including layout, spacing, typography, and responsive behavior. This is a coherent cluster because theme developers must translate commerce designs into usable storefront pages.",
          "slug": "storefront-styling-and-responsive-layout",
          "source": "db"
        },
        "dimension_id": 423,
        "input_skill": "Sass",
        "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": 624,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Design and Contracts",
          "id": 3,
          "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
          "slug": "api-design-and-contracts",
          "source": "db"
        },
        "dimension_id": 3,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Interface and Contract Design",
          "id": 289,
          "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
          "slug": "api-interface-and-contract-design",
          "source": "db"
        },
        "dimension_id": 289,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Integration Protocols \u0026 Standards",
          "id": 271,
          "rationale": "Standards and protocols for integrating Pega applications.",
          "slug": "integration-protocols-standards",
          "source": "db"
        },
        "dimension_id": 271,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Standards \u0026 Protocols Compliance",
          "id": 452,
          "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
          "slug": "standards-protocols-compliance",
          "source": "db"
        },
        "dimension_id": 452,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "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": "JSON",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1984,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Interface and Contract Design",
          "id": 289,
          "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
          "slug": "api-interface-and-contract-design",
          "source": "db"
        },
        "dimension_id": 289,
        "input_skill": "JSON",
        "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": 1984,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Integration Protocols \u0026 Standards",
          "id": 271,
          "rationale": "Standards and protocols for integrating Pega applications.",
          "slug": "integration-protocols-standards",
          "source": "db"
        },
        "dimension_id": 271,
        "input_skill": "JSON",
        "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": 1984,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Agile",
        "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": 520,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Scrum",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1215,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 0
  },
  "planner_output": null,
  "run_id": "90a79cd7-55d4-4b8a-a17e-93346336ae76"
}

LLM Calls

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

Loading…