← Back to history

Pipeline run

58445421-dd03-4bd0-ad5e-f9238778d282

Pipeline LLM cost (USD)
API 1: $0.0086 API 2: $0.0001 API 3: $0.0000 Total: $0.0087

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 ship web tooling/solutions with HTML/CSS/TypeScript, pairing with UX and business stakeholders, and covering unit/E2E testing plus GCP-backed delivery. Day to day, the work is mostly frontend implementation with some database/backend collaboration.
""Design web solutions with business stakeholders""
Tech stack maturity
Mainstream Modern
The skill mix centers on modern frontend technologies like JavaScript, TypeScript, and unit testing, with GCP indicating cloud familiarity but not necessarily cloud-native or bleeding-edge specialization.
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 (12)
JavaScript HTML CSS TypeScript Unit Testing End-to-End Testing GCP Python MySQL Angular Dart Java SQL
Skill cluster (7 dimension groups, role-scoped)
JavaScript and TypeScript
JavaScript TypeScript
CSS Architecture and Styling
CSS
Cloud Provider Platforms
GCP
Java Language and JVM
Java
Python Programming
Python
Relational Database Usage
MySQL
Cross-cutting / unaligned
HTML Unit Testing End-to-End Testing Angular Dart SQL
Show KRA description ↓
Be responsible for tools delivery Work with the most recent technologies Design web solutions with business stakeholders Cooperate with UX Designers 3+ years of relevant experience Expertise in  HTML/CSS, TypeScript Unit and E2E Testing experience Experience with GCP English B2+ (both written and speaking) Great communication skills Knowledge of Python would be a plus Experience with MySQL Database or any other RDBMS, Angular Dart will be a plus Strong Java Back-end expertise with experience in SQL and data pipelines is nice to have MySQL Unit Testing

Signals

Skill full-stack-engineer
0.57
Alias frontend-engineer
1.00
KRA full-stack-engineer
0.47

Post-classification

Centroidupdated · n=390
Alias collision log#883
New-role queue
New skills captured2
New KRA capturedyes

Captured for admin review

End-to-End Testing primary Frontend Developer pending
Angular Dart Frontend Developer pending
R&R fragment (sim 0.00) Frontend Developer pending

Be responsible for tools delivery Work with the most recent technologies Design web solutions with business stakeholders Cooperate with UX Designers 3+ years of relevant experience Expertise in  HTML…

Status: completed Created: 2026-05-27T15:57:51.745052Z Updated: 2026-06-12T15:38:37.212547Z API 3 duration: 105343 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

CASE D

slug: frontend-engineer · id: 7 · source: db

LLM2 picked frontend-engineer (confidence 0.90)

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

Job description

We would be happy to consider your applications if you are willing to join EPAM Anywhere by 15 December 2022 inclusively. Applications with later onboarding dates will not be considered.

Are you a tech professional looking for remote work in a global setting? If yes, this job is for you.

Welcome to EPAM Anywhere - a global job platform offering remote work opportunities in the technology sector. Join us to build a career around your lifestyle working on modern projects for global brands and exciting startups.

Currently, we are looking for aremote Senior JavaScript Developer to join our team.

Responsibilities

Be responsible for tools delivery
Work with the most recent technologies
Design web solutions with business stakeholders
Cooperate with UX Designers


Requirements

3+ years of relevant experience
Expertise in  HTML/CSS, TypeScript
Unit and E2E Testing experience
Experience with GCP
English B2+ (both written and speaking)
Great communication skills
Knowledge of Python would be a plus
Experience with MySQL Database or any other RDBMS, Angular Dart will be a plus
Strong Java Back-end expertise with experience in SQL and data pipelines is nice to have


Nice to have

MySQL
Unit Testing


We offer

Insurance Coverage
Paid Leaves – including maternity, bereavement, paternity, and special COVID-19 leaves.
Financial assistance for medical crisis
Retiral Benefits – VPF and NPS
Customized Mindfulness and Wellness programs
EPAM Hobby Clubs
Hybrid Work Model
Soft loans to set up workspace at home
Stable workload
Relocation opportunities with ‘EPAM without Borders’ program
Certification trainings for technical and soft skills
Access to unlimited LinkedIn Learning platform
Access to internal learning programs set up by world class trainers
Community networking and idea creation platforms
Mentorship programs
Self-driven career progression tool


This is a remote position and we welcome applications from anywhere in India

Once you apply, you'll receive a confirmation email with a link to EPAM Anywhere platform. Sign up with this link to automate your prescreening, be able to monitor your application statuses, and enjoy a faster job application process.

We accept CVs only in English.

Please note that even though you are applying for this position, you may be offered other projects to join within EPAM Anywhere.

EPAM Anywhere is a part of EPAM Systems, Inc. (NYSE: EPAM). Since 1993, EPAM has leveraged its advanced software engineering heritage to become the foremost global digital transformation services provider.

Skills from this JD

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

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

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cross-Platform App Languages Catalog dimension db id 167

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer

  • JavaScript and TypeScript Catalog dimension db id 114

    Library dimension (catalog)

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

  • JavaScript for WordPress Catalog dimension db id 329

    Library dimension (catalog)

    Roles linked in library: WordPress Dev

  • Pega Programming Languages & DSLs Catalog dimension db id 267

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages & DSLs Catalog dimension db id 475

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

  • Programming Languages & Template Languages Catalog dimension db id 359

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Storefront JavaScript and DOM Behavior Catalog dimension db id 422

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension 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 & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Storefront JavaScript and DOM Behavior
storefront-javascript-and-dom-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: HTML id=1657 · html

Aliases — catalog

  • HTML (CANONICAL) primary

Context tags (catalog)

ARIA CSS DOM HTML5 JavaScript SEO SVG W3C W3C standards canvas forms front-end development markup validation meta tags microdata responsive design semantic markup web accessibility web components

Stored enrichment (catalog DB)

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

Maturity reasoning: HTML appears in the vast majority of web/front-end job descriptions and remains a core browser standard; it is not sunset or replaced by a newer markup language.

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)

  • Pega Programming Languages & DSLs Catalog dimension db id 267

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Programming Languages & Template Languages Catalog dimension db id 359

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
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, 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)
TypeScript Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: TypeScript id=524 · typescript

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cross-Platform App Languages Catalog dimension db id 167

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer

  • JavaScript and TypeScript Catalog dimension db id 114

    Library dimension (catalog)

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

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

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

Aliases — catalog

  • Unit Testing (CANONICAL)

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
End-to-End Testing Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: end-to-end tests id=58 · end-to-end-tests

Aliases — catalog

  • end-to-end tests (CANONICAL) primary

Context tags (catalog)

CI/CD Cypress Playwright Puppeteer Selenium TestCafe UI automation WebDriver browser automation integration tests mocking regression testing smoke tests test fixtures test harness

Stored enrichment (catalog DB)

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

Maturity reasoning: Commonly listed in QA/SDET and frontend/backend JDs; tools like Cypress, Playwright, and Selenium show strong GitHub and job-market demand for E2E testing.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Testing and Quality Assurance Catalog dimension db id 12

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Testing and Quality Assurance
testing-and-quality-assurance
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
GCP Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: GCP id=186 · gcp

Aliases — catalog

  • GCP (CANONICAL) primary

Context tags (catalog)

Anthos App Engine Artifact Registry BigQuery Cloud Build Cloud Composer Cloud Functions Cloud Logging Cloud Monitoring Cloud Run Cloud SQL Cloud Spanner Cloud Storage Compute Engine Dataflow GKE IAM Kubernetes Pub/Sub Service Accounts Stackdriver Terraform VPC

Stored enrichment (catalog DB)

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

Maturity reasoning: GCP appears frequently in cloud/platform job descriptions and is a major hyperscaler alongside AWS/Azure, with broad enterprise adoption and active vendor investment.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

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

  • Cloud Platforms for AI Deployment Catalog dimension db id 211

    Library dimension (catalog)

    Roles linked in library: AI Engineer

  • Cloud Provider Platforms Catalog dimension db id 131

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, Cloud Security Engineer

  • Cloud Security Posture Tools Catalog dimension db id 64

    Library dimension (catalog)

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

API 3 link attempts (this skill)

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

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

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

    Library dimension (catalog)

    Roles linked in library: Cloud Security Engineer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages & DSLs Catalog dimension db id 475

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

  • Programming Languages and Scripting Catalog dimension db id 59

    Library dimension (catalog)

    Roles linked in library: Cyber Security Engineer

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

  • Programming Languages for ML Systems Catalog dimension db id 39

    Library dimension (catalog)

    Roles linked in library: ML Engineer, MLOps Engineer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • Python Programming Catalog dimension db id 290

    Library dimension (catalog)

    Roles linked in library: Python Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages and Scripting
programming-languages-and-scripting
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python Programming
python-programming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: MySQL id=17 · mysql

Aliases — catalog

  • MySQL (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Relational Data Modeling Catalog dimension db id 216

    Library dimension (catalog)

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

  • Relational Database Design Catalog dimension db id 4

    Library dimension (catalog)

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

  • Relational Database Usage Catalog dimension db id 371

    Library dimension (catalog)

    Roles linked in library: Go Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Relational Data Modeling
relational-data-modeling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Relational Database Usage
relational-database-usage
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Angular Dart 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
Java Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Java id=1 · java

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Java Language and JVM Catalog dimension db id 279

    Library dimension (catalog)

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

  • Kotlin and Java Catalog dimension db id 161

    Library dimension (catalog)

    Roles linked in library: Android Developer

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Pega Programming Languages & DSLs Catalog dimension db id 267

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages & DSLs Catalog dimension db id 475

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

API 3 link attempts (this skill)

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

Aliases — catalog

  • SQL (CANONICAL) primary

Context tags (catalog)

ACID CTE DDL DML ETL JOIN MySQL NoSQL OLAP ORM PostgreSQL SQL injection SQLite T-SQL data modeling data warehousing database normalization execution plan indexing joins normalization query optimization stored procedures subquery transaction isolation transaction management window functions

Stored enrichment (catalog DB)

Category
Language
Sub-category
Query Language
Vendor
ANSI
License
unknown
Year introduced
1974
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: SQL appears in a large share of data, backend, and analytics job descriptions and remains the default query language for PostgreSQL, MySQL, and cloud warehouses like Snowflake/BigQuery.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Pega Programming Languages & DSLs Catalog dimension db id 267

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Programming Languages & DSLs Catalog dimension db id 475

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

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 & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Storefront JavaScript and DOM Behavior
storefront-javascript-and-dom-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML in_db
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML in_db
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML in_db
Sitecore Development Languages
sitecore-development-languages
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)
TypeScript in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension saved
TypeScript in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unit Testing in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
End-to-End Testing new
Testing and Quality Assurance
testing-and-quality-assurance
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed
GCP in_db
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GCP in_db
Cloud Platforms for AI Deployment
cloud-platforms-for-ai-deployment
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GCP in_db
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GCP in_db
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages and Scripting
programming-languages-and-scripting
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Python Programming
python-programming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL in_db
Relational Data Modeling
relational-data-modeling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL in_db
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL in_db
Relational Database Usage
relational-database-usage
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Java Language and JVM
java-language-and-jvm
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Kotlin and Java
kotlin-and-java
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Java in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SQL in_db
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SQL in_db
Programming Languages & DSLs
programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SQL in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed Angular Dart | type=Web Frameworks subtype=general nature=TOOL lifespan=MULTI_YEAR
dimension_skill_link_proposed End-to-End Testing ↔ Testing and Quality Assurance
nano JD Parser — gpt-4.1-nano click to toggle
RoleSenior JavaScript Developer
CompanyEPAM Systems, Inc.
Experience3+ years of relevant experience
DomainIT Services & Consulting
Location India (remote)
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": {
    "source_marker": {
      "first_5_words": "EPAM Anywhere is a part",
      "last_5_words": "global digital transformation services provider."
    },
    "text": "EPAM Anywhere is a part of EPAM Systems, Inc. (NYSE: EPAM). Since 1993, EPAM has leveraged its advanced software engineering heritage to become the foremost global digital transformation services provider.",
    "word_count": 36
  },
  "certifications": [],
  "company_name": "EPAM Systems, Inc.",
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [
        "ITES",
        "BPO",
        "Tech Consulting"
      ],
      "domain": "IT Services \u0026 Consulting"
    },
    "secondary": null
  },
  "education": [],
  "experience": {
    "max": null,
    "min": 3,
    "raw": "3+ years of relevant experience"
  },
  "job_locations": [
    {
      "aliases": [],
      "city": null,
      "country": "India",
      "state": null,
      "work_mode": "remote"
    }
  ],
  "role": "Senior JavaScript Developer",
  "role_aliases": [
    "JavaScript Developer",
    "JS Developer",
    "Frontend Developer"
  ],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 4,
      "heading": "Responsibilities",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Be responsible for tools delivery",
        "last_5_words": "with business stakeholders\nCooperate with UX Designers"
      },
      "text": "Be responsible for tools delivery\nWork with the most recent technologies\nDesign web solutions with business stakeholders\nCooperate with UX Designers",
      "word_count": 24
    },
    {
      "bullet_count": 9,
      "heading": "Requirements",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "3+ years of relevant experience",
        "last_5_words": "experience in SQL and data pipelines is nice to have"
      },
      "text": "3+ years of relevant experience\nExpertise in\u202f HTML/CSS, TypeScript\nUnit and E2E Testing experience\nExperience with GCP\nEnglish B2+ (both written and speaking)\nGreat communication skills\nKnowledge of Python would be a plus\nExperience with\u202fMySQL\u202fDatabase or any other RDBMS, Angular Dart will be a plus\nStrong Java Back-end expertise with experience in SQL and data pipelines is nice to have",
      "word_count": 81
    },
    {
      "bullet_count": 2,
      "heading": "Nice to have",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "MySQL\nUnit Testing",
        "last_5_words": "MySQL\nUnit Testing"
      },
      "text": "MySQL\nUnit Testing",
      "word_count": 4
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "JavaScript"
    },
    {
      "is_primary": true,
      "skill_name": "HTML"
    },
    {
      "is_primary": true,
      "skill_name": "CSS"
    },
    {
      "is_primary": true,
      "skill_name": "TypeScript"
    },
    {
      "is_primary": true,
      "skill_name": "Unit Testing"
    },
    {
      "is_primary": true,
      "skill_name": "End-to-End Testing"
    },
    {
      "is_primary": true,
      "skill_name": "GCP"
    },
    {
      "is_primary": false,
      "skill_name": "Python"
    },
    {
      "is_primary": false,
      "skill_name": "MySQL"
    },
    {
      "is_primary": false,
      "skill_name": "Angular Dart"
    },
    {
      "is_primary": false,
      "skill_name": "Java"
    },
    {
      "is_primary": false,
      "skill_name": "SQL"
    }
  ],
  "jd_role": {
    "display_name": "Senior JavaScript Developer",
    "rationale": null,
    "role_aliases": [
      "JavaScript Developer",
      "JS Developer",
      "Frontend Developer"
    ],
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": {
      "source_marker": {
        "first_5_words": "EPAM Anywhere is a part",
        "last_5_words": "global digital transformation services provider."
      },
      "text": "EPAM Anywhere is a part of EPAM Systems, Inc. (NYSE: EPAM). Since 1993, EPAM has leveraged its advanced software engineering heritage to become the foremost global digital transformation services provider.",
      "word_count": 36
    },
    "certifications": [],
    "company_name": "EPAM Systems, Inc.",
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [
          "ITES",
          "BPO",
          "Tech Consulting"
        ],
        "domain": "IT Services \u0026 Consulting"
      },
      "secondary": null
    },
    "education": [],
    "experience": {
      "max": null,
      "min": 3,
      "raw": "3+ years of relevant experience"
    },
    "job_locations": [
      {
        "aliases": [],
        "city": null,
        "country": "India",
        "state": null,
        "work_mode": "remote"
      }
    ],
    "role": "Senior JavaScript Developer",
    "role_aliases": [
      "JavaScript Developer",
      "JS Developer",
      "Frontend Developer"
    ],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 4,
        "heading": "Responsibilities",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Be responsible for tools delivery",
          "last_5_words": "with business stakeholders\nCooperate with UX Designers"
        },
        "text": "Be responsible for tools delivery\nWork with the most recent technologies\nDesign web solutions with business stakeholders\nCooperate with UX Designers",
        "word_count": 24
      },
      {
        "bullet_count": 9,
        "heading": "Requirements",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "3+ years of relevant experience",
          "last_5_words": "experience in SQL and data pipelines is nice to have"
        },
        "text": "3+ years of relevant experience\nExpertise in\u202f HTML/CSS, TypeScript\nUnit and E2E Testing experience\nExperience with GCP\nEnglish B2+ (both written and speaking)\nGreat communication skills\nKnowledge of Python would be a plus\nExperience with\u202fMySQL\u202fDatabase or any other RDBMS, Angular Dart will be a plus\nStrong Java Back-end expertise with experience in SQL and data pipelines is nice to have",
        "word_count": 81
      },
      {
        "bullet_count": 2,
        "heading": "Nice to have",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "MySQL\nUnit Testing",
          "last_5_words": "MySQL\nUnit Testing"
        },
        "text": "MySQL\nUnit Testing",
        "word_count": 4
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "58445421-dd03-4bd0-ad5e-f9238778d282",
  "stage3_signals": {
    "alias_found": true,
    "alias_match_roles": [
      {
        "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
      },
      {
        "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": 439,
        "score": 1.0,
        "slug": "frontend-developer",
        "total_count": null
      }
    ],
    "kra_match_roles": [
      {
        "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": "Design web solutions with business stakeholders",
            "similarity": 0.5403
          },
          {
            "kra_text": "Designs and queries relational databases like PostgreSQL and document stores like MongoDB, writing migrations, indexes, and optimized queries.",
            "sentence": "Experience with\u202fMySQL\u202fDatabase or any other RDBMS, Angular Dart will be a plus",
            "similarity": 0.4711
          },
          {
            "kra_text": "Implements complete product features end-to-end from database schema design through backend API to frontend UI using JavaScript, TypeScript, Python, or Ruby on Rails.",
            "sentence": "Strong Java Back-end expertise with experience in SQL and data pipelines is nice to have",
            "similarity": 0.4059
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 15,
        "score": 0.4724,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Svelte Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "backend data integration",
            "sentence": "Strong Java Back-end expertise with experience in SQL and data pipelines is nice to have",
            "similarity": 0.4426
          },
          {
            "kra_text": "accessibility and usability",
            "sentence": "Design web solutions with business stakeholders",
            "similarity": 0.4182
          },
          {
            "kra_text": "backend data integration",
            "sentence": "Experience with\u202fMySQL\u202fDatabase or any other RDBMS, Angular Dart will be a plus",
            "similarity": 0.4098
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 92,
        "score": 0.4236,
        "slug": "svelte-frontend-developer",
        "total_count": null
      },
      {
        "display_name": "Flutter Developer",
        "kra_matches": [
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Design web solutions with business stakeholders",
            "similarity": 0.5455
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Strong Java Back-end expertise with experience in SQL and data pipelines is nice to have",
            "similarity": 0.3707
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Experience with\u202fMySQL\u202fDatabase or any other RDBMS, Angular Dart will be a plus",
            "similarity": 0.3324
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 74,
        "score": 0.4162,
        "slug": "flutter-developer",
        "total_count": null
      },
      {
        "display_name": "Backend Developer",
        "kra_matches": [
          {
            "kra_text": "Writes database access logic including SQL queries, ORM mappings, stored procedures, and migration scripts for relational databases like PostgreSQL and MySQL.",
            "sentence": "Experience with\u202fMySQL\u202fDatabase or any other RDBMS, Angular Dart will be a plus",
            "similarity": 0.4507
          },
          {
            "kra_text": "Writes database access logic including SQL queries, ORM mappings, stored procedures, and migration scripts for relational databases like PostgreSQL and MySQL.",
            "sentence": "Strong Java Back-end expertise with experience in SQL and data pipelines is nice to have",
            "similarity": 0.4082
          },
          {
            "kra_text": "Designs and maintains RESTful and GraphQL API interfaces with proper authentication, versioning, rate limiting, and documentation for frontend and third-party consumers.",
            "sentence": "Design web solutions with business stakeholders",
            "similarity": 0.3587
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 1,
        "score": 0.4059,
        "slug": "backend-engineer",
        "total_count": null
      },
      {
        "display_name": "Angular Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "collaboration with design and QA",
            "sentence": "Design web solutions with business stakeholders",
            "similarity": 0.5263
          },
          {
            "kra_text": "Angular component development",
            "sentence": "Experience with\u202fMySQL\u202fDatabase or any other RDBMS, Angular Dart will be a plus",
            "similarity": 0.3747
          },
          {
            "kra_text": "backend endpoint integration",
            "sentence": "Strong Java Back-end expertise with experience in SQL and data pipelines is nice to have",
            "similarity": 0.3159
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 90,
        "score": 0.4056,
        "slug": "angular-frontend-developer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": 4,
        "matched_skills": [
          "CSS",
          "GCP",
          "JavaScript",
          "TypeScript"
        ],
        "role_id": 15,
        "score": 0.5714,
        "slug": "full-stack-engineer",
        "total_count": 7
      },
      {
        "display_name": "Sitecore Dev",
        "kra_matches": null,
        "matched_count": 4,
        "matched_skills": [
          "CSS",
          "HTML",
          "JavaScript",
          "TypeScript"
        ],
        "role_id": 233,
        "score": 0.5714,
        "slug": "sitecore-dev",
        "total_count": 7
      },
      {
        "display_name": "Backend Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "GCP",
          "JavaScript",
          "TypeScript"
        ],
        "role_id": 1,
        "score": 0.4286,
        "slug": "backend-engineer",
        "total_count": 7
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "CSS",
          "JavaScript",
          "TypeScript"
        ],
        "role_id": 7,
        "score": 0.4286,
        "slug": "frontend-engineer",
        "total_count": 7
      },
      {
        "display_name": "Web Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "CSS",
          "JavaScript",
          "TypeScript"
        ],
        "role_id": 25,
        "score": 0.4286,
        "slug": "web-developer",
        "total_count": 7
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": true,
    "case": "D",
    "chosen_role": {
      "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
    },
    "confidence": 0.9,
    "is_new_role": false,
    "llm2_fired": true,
    "llm2_reasoning": "The Frontend Engineer\u2019s Top KRAs and skills in HTML/CSS, TypeScript, Angular, and testing best match the JD\u2019s requirements for web solution design, UX collaboration, and unit/E2E testing.",
    "matched_dimensions": [],
    "matched_kras": [],
    "matched_skills": [],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "LLM2 picked frontend-engineer (confidence 0.90)",
    "sub_role": null
  },
  "stage5_updates": {
    "centroid_n_after": 390,
    "centroid_updated": true,
    "collision_log_id": 883,
    "new_kra_attached": {
      "best_kra_similarity": 0.0,
      "queue_id": 1271,
      "r_and_r_preview": "Be responsible for tools delivery\nWork with the most recent technologies\nDesign web solutions with business stakeholders\nCooperate with UX Designers\n\n3+ years of relevant experience\nExpertise in\u202f HTML",
      "role_display_name": "Frontend Developer",
      "role_slug": "frontend-engineer",
      "status": "pending"
    },
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 17504,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "End-to-End Testing",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 17505,
        "role_display_name": "Frontend Developer",
        "role_slug": "frontend-engineer",
        "skill_name": "Angular Dart",
        "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": 2627,
      "existing_alias_text": "HTML",
      "input_term": "HTML",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "HTML",
        "id": 1657,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "html",
        "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": 914,
      "existing_alias_text": "TypeScript",
      "input_term": "TypeScript",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "TypeScript",
        "id": 524,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 865,
      "existing_alias_text": "Unit Testing",
      "input_term": "Unit Testing",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Unit Testing",
        "id": 517,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "unit-testing",
        "sub_category_id": 44,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": 195,
      "existing_alias_text": "end-to-end tests",
      "input_term": "End-to-End Testing",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "end-to-end tests",
        "id": 58,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "end-to-end-tests",
        "sub_category_id": 44,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 405,
      "existing_alias_text": "GCP",
      "input_term": "GCP",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "GCP",
        "id": 186,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "gcp",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 67,
      "existing_alias_text": "Python",
      "input_term": "Python",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 134,
      "existing_alias_text": "MySQL",
      "input_term": "MySQL",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "MySQL",
        "id": 17,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mysql",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1,
      "existing_alias_text": "Java",
      "input_term": "Java",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Java",
        "id": 1,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "java",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 271,
      "existing_alias_text": "SQL",
      "input_term": "SQL",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "SQL",
        "id": 101,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "sql",
        "sub_category_id": 97,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "Angular Frontend Developer",
      "id": 90,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "angular-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Frontend Developer",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "Ionic Developer",
      "id": 434,
      "rationale": null,
      "role_archetype": null,
      "slug": "ionic-developer",
      "source": "db"
    },
    {
      "display_name": "Node.js Backend Developer",
      "id": 82,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "node-backend-developer",
      "source": "db"
    },
    {
      "display_name": "React Frontend Developer",
      "id": 89,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "React Native Developer",
      "id": 73,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-native-developer",
      "source": "db"
    },
    {
      "display_name": "Svelte Frontend Developer",
      "id": 92,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "svelte-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Vue Frontend Developer",
      "id": 91,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "vue-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Web Developer",
      "id": 25,
      "rationale": null,
      "role_archetype": null,
      "slug": "web-developer",
      "source": "db"
    },
    {
      "display_name": "WordPress Dev",
      "id": 227,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "wordpress-dev",
      "source": "db"
    },
    {
      "display_name": "Pega Developer",
      "id": 24,
      "rationale": null,
      "role_archetype": null,
      "slug": "pega-developer",
      "source": "db"
    },
    {
      "display_name": "Backend Developer",
      "id": 1,
      "rationale": null,
      "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
      "slug": "backend-engineer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 15,
      "rationale": null,
      "role_archetype": null,
      "slug": "full-stack-engineer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 435,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "fullstack-developer",
      "source": "db"
    },
    {
      "display_name": "Engineering Manager",
      "id": 121,
      "rationale": null,
      "role_archetype": null,
      "slug": "engineering-manager",
      "source": "db"
    },
    {
      "display_name": "Drupal Dev",
      "id": 228,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "drupal-dev",
      "source": "db"
    },
    {
      "display_name": "Sitecore Dev",
      "id": 233,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "sitecore-dev",
      "source": "db"
    },
    {
      "display_name": "Shopify Dev",
      "id": 230,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "shopify-dev",
      "source": "db"
    },
    {
      "display_name": "AR/VR Engineer",
      "id": 8,
      "rationale": null,
      "role_archetype": null,
      "slug": "ar-vr-engineer",
      "source": "db"
    },
    {
      "display_name": ".NET Backend Developer",
      "id": 83,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "dotnet-backend-developer",
      "source": "db"
    },
    {
      "display_name": "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": "Scala Backend Developer",
      "id": 87,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "scala-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Cyber Security Engineer",
      "id": 5,
      "rationale": null,
      "role_archetype": null,
      "slug": "cybersecurity-engineer",
      "source": "db"
    },
    {
      "display_name": "Data Engineer",
      "id": 2,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-engineer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "Go Backend Developer",
      "id": 81,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "go-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Java Backend Developer",
      "id": 79,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "java-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Kotlin Backend Developer",
      "id": 84,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "kotlin-server-backend-developer",
      "source": "db"
    },
    {
      "display_name": "ML Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-engineer",
      "source": "db"
    },
    {
      "display_name": "MLOps Engineer",
      "id": 16,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-ops-engineer",
      "source": "db"
    },
    {
      "display_name": "AI Engineer",
      "id": 13,
      "rationale": null,
      "role_archetype": null,
      "slug": "ai-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Architect",
      "id": 9,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-architect",
      "source": "db"
    },
    {
      "display_name": "Cloud Security Engineer",
      "id": 23,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-security-engineer",
      "source": "db"
    },
    {
      "display_name": "Ruby Backend Developer",
      "id": 85,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "ruby-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Android Developer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "android-engineer",
      "source": "db"
    },
    {
      "display_name": "Native Mobile Developer",
      "id": 75,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "native-mobile-developer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Frontend Developer",
    "id": 7,
    "rationale": "LLM2 picked frontend-engineer (confidence 0.90)",
    "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"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 DSLs",
        "id": 475,
        "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
        "slug": "programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 Template Languages",
        "id": 359,
        "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
        "slug": "programming-languages-template-languages",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Storefront JavaScript and DOM Behavior",
        "id": 422,
        "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
        "slug": "storefront-javascript-and-dom-behavior",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "HTML",
      "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 \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": "HTML",
      "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": "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": "HTML",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "HTML",
      "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": "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": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "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": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "JavaScript and TypeScript",
        "id": 114,
        "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
        "slug": "javascript-and-typescript",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Unit Testing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Testing and Quality Assurance",
        "id": 12,
        "rationale": "Backend-specific test strategies used to validate service behavior and integration points. Covers automated test layers, contract checks, fixtures, and regression prevention.",
        "slug": "testing-and-quality-assurance",
        "source": "db"
      },
      "input_skill": "End-to-End Testing",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "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": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        },
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms for AI Deployment",
        "id": 211,
        "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
        "slug": "cloud-platforms-for-ai-deployment",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Provider Platforms",
        "id": 131,
        "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
        "slug": "cloud-provider-platforms",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Posture Tools",
        "id": 64,
        "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
        "slug": "cloud-security-posture-tools",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        },
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Scripting \u0026 DSL Languages",
        "id": 248,
        "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
        "slug": "cloud-security-scripting-dsl-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 DSLs",
        "id": 475,
        "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
        "slug": "programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages and Scripting",
        "id": 59,
        "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
        "slug": "programming-languages-and-scripting",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 21,
        "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 39,
        "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Python Programming",
        "id": 290,
        "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
        "slug": "python-programming",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Relational Data Modeling",
        "id": 216,
        "rationale": "Modeling and tuning relational persistence for backend features. PHP backend developers need this to shape schemas, indexes, transactions, and query-aware data structures that support application behavior.",
        "slug": "relational-data-modeling",
        "source": "db"
      },
      "input_skill": "MySQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Relational Database Design",
        "id": 4,
        "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
        "slug": "relational-database-design",
        "source": "db"
      },
      "input_skill": "MySQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Relational Database Usage",
        "id": 371,
        "rationale": "Working effectively with operational relational databases from Go backend services. This includes schema-aware querying, indexing awareness, transactions, and understanding how service code interacts with PostgreSQL or similar systems.",
        "slug": "relational-database-usage",
        "source": "db"
      },
      "input_skill": "MySQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Java Language and JVM",
        "id": 279,
        "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
        "slug": "java-language-and-jvm",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kotlin and Java",
        "id": 161,
        "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
        "slug": "kotlin-and-java",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Pega Programming Languages \u0026 DSLs",
        "id": 267,
        "rationale": "Programming languages and domain-specific languages used in Pega development.",
        "slug": "pega-programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 DSLs",
        "id": 475,
        "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
        "slug": "programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 21,
        "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "SQL",
      "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 \u0026 DSLs",
        "id": 475,
        "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
        "slug": "programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "SQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 21,
        "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "SQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "JavaScript",
    "HTML",
    "CSS",
    "TypeScript",
    "Unit Testing",
    "End-to-End Testing",
    "GCP",
    "Python",
    "MySQL",
    "Angular Dart",
    "Java",
    "SQL"
  ],
  "input_llm_skills": [
    "JavaScript",
    "HTML",
    "CSS",
    "TypeScript",
    "Unit Testing",
    "End-to-End Testing",
    "GCP",
    "Python",
    "MySQL",
    "Angular Dart",
    "Java",
    "SQL"
  ],
  "new_aliases_persisted": 0,
  "run_id": "58445421-dd03-4bd0-ad5e-f9238778d282",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "JavaScript",
          "alias_type": "CANONICAL",
          "id": 1028,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2015",
          "alias_type": "VERSION",
          "id": 1031,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2016",
          "alias_type": "VERSION",
          "id": 1032,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2017",
          "alias_type": "VERSION",
          "id": 1033,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2018",
          "alias_type": "VERSION",
          "id": 1034,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2019",
          "alias_type": "VERSION",
          "id": 1035,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2020",
          "alias_type": "VERSION",
          "id": 1036,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2021",
          "alias_type": "VERSION",
          "id": 1037,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2022",
          "alias_type": "VERSION",
          "id": 1038,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2023",
          "alias_type": "VERSION",
          "id": 1039,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES2024",
          "alias_type": "VERSION",
          "id": 1040,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES5",
          "alias_type": "VERSION",
          "id": 1029,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ES6",
          "alias_type": "VERSION",
          "id": 1030,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JavaScript ES2015",
          "alias_type": "VERSION",
          "id": 1042,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JavaScript ES2020",
          "alias_type": "VERSION",
          "id": 1043,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JavaScript ES6",
          "alias_type": "VERSION",
          "id": 1041,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "modern JavaScript",
          "alias_type": "VERSION",
          "id": 1044,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "JavaScript",
        "id": 607,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "javascript",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript and TypeScript",
            "id": 114,
            "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
            "slug": "javascript-and-typescript",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript for WordPress",
            "id": 329,
            "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
            "slug": "javascript-for-wordpress",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "WordPress Dev",
              "id": 227,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "wordpress-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Pega Programming Languages \u0026 DSLs",
            "id": 267,
            "rationale": "Programming languages and domain-specific languages used in Pega development.",
            "slug": "pega-programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \u0026 DSLs",
            "id": 475,
            "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
            "slug": "programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \u0026 Template Languages",
            "id": 359,
            "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
            "slug": "programming-languages-template-languages",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Sitecore Development Languages",
            "id": 438,
            "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
            "slug": "sitecore-development-languages",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Storefront JavaScript and DOM Behavior",
            "id": 422,
            "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
            "slug": "storefront-javascript-and-dom-behavior",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "JavaScript",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "HTML",
          "alias_type": "CANONICAL",
          "id": 2627,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "HTML",
        "id": 1657,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "html",
        "sub_category_id": 1467,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "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": "HTML",
          "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 \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": "HTML",
          "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": "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": "HTML",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Sitecore Development Languages",
            "id": 438,
            "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
            "slug": "sitecore-development-languages",
            "source": "db"
          },
          "input_skill": "HTML",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "HTML",
      "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": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "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": "TypeScript",
          "alias_type": "CANONICAL",
          "id": 914,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5",
          "alias_type": "VERSION",
          "id": 3157,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5.x",
          "alias_type": "VERSION",
          "id": 3159,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ts",
          "alias_type": "VERSION",
          "id": 1647,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ts5",
          "alias_type": "VERSION",
          "id": 1648,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript 5",
          "alias_type": "VERSION",
          "id": 1649,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript 5.x",
          "alias_type": "VERSION",
          "id": 1650,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript5",
          "alias_type": "VERSION",
          "id": 2179,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "TypeScript",
        "id": 524,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript and TypeScript",
            "id": 114,
            "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
            "slug": "javascript-and-typescript",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Sitecore Development Languages",
            "id": 438,
            "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
            "slug": "sitecore-development-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "TypeScript",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Unit Testing",
          "alias_type": "CANONICAL",
          "id": 865,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Unit Testing",
        "id": 517,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "unit-testing",
        "sub_category_id": 44,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Unit Testing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Unit Testing",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "end-to-end tests",
          "alias_type": "CANONICAL",
          "id": 195,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "end-to-end tests",
        "id": 58,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "end-to-end-tests",
        "sub_category_id": 44,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Testing and Quality Assurance",
            "id": 12,
            "rationale": "Backend-specific test strategies used to validate service behavior and integration points. Covers automated test layers, contract checks, fixtures, and regression prevention.",
            "slug": "testing-and-quality-assurance",
            "source": "db"
          },
          "input_skill": "End-to-End Testing",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "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": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "End-to-End Testing",
      "matched_via": "embedding_alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "GCP",
          "alias_type": "CANONICAL",
          "id": 405,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "GCP",
        "id": 186,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "gcp",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            },
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms for AI Deployment",
            "id": 211,
            "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
            "slug": "cloud-platforms-for-ai-deployment",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Provider Platforms",
            "id": 131,
            "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
            "slug": "cloud-provider-platforms",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Posture Tools",
            "id": 64,
            "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
            "slug": "cloud-security-posture-tools",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            },
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "GCP",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Python",
          "alias_type": "CANONICAL",
          "id": 67,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2",
          "alias_type": "VERSION",
          "id": 72,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2.x",
          "alias_type": "VERSION",
          "id": 74,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3",
          "alias_type": "VERSION",
          "id": 73,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.10",
          "alias_type": "VERSION",
          "id": 76,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.11",
          "alias_type": "VERSION",
          "id": 77,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.12",
          "alias_type": "VERSION",
          "id": 78,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.x",
          "alias_type": "VERSION",
          "id": 75,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py",
          "alias_type": "VERSION",
          "id": 2183,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py2",
          "alias_type": "VERSION",
          "id": 68,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py3",
          "alias_type": "VERSION",
          "id": 69,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3",
          "alias_type": "VERSION",
          "id": 2186,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.x",
          "alias_type": "VERSION",
          "id": 2849,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python2",
          "alias_type": "VERSION",
          "id": 70,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3",
          "alias_type": "VERSION",
          "id": 71,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3.x",
          "alias_type": "VERSION",
          "id": 2848,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Scripting \u0026 DSL Languages",
            "id": 248,
            "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
            "slug": "cloud-security-scripting-dsl-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \u0026 DSLs",
            "id": 475,
            "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
            "slug": "programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages and Scripting",
            "id": 59,
            "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
            "slug": "programming-languages-and-scripting",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 21,
            "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 39,
            "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Python Programming",
            "id": 290,
            "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
            "slug": "python-programming",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Python",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "MySQL",
          "alias_type": "CANONICAL",
          "id": 134,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "MySQL",
        "id": 17,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mysql",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Data Modeling",
            "id": 216,
            "rationale": "Modeling and tuning relational persistence for backend features. PHP backend developers need this to shape schemas, indexes, transactions, and query-aware data structures that support application behavior.",
            "slug": "relational-data-modeling",
            "source": "db"
          },
          "input_skill": "MySQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Database Design",
            "id": 4,
            "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
            "slug": "relational-database-design",
            "source": "db"
          },
          "input_skill": "MySQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Database Usage",
            "id": 371,
            "rationale": "Working effectively with operational relational databases from Go backend services. This includes schema-aware querying, indexing awareness, transactions, and understanding how service code interacts with PostgreSQL or similar systems.",
            "slug": "relational-database-usage",
            "source": "db"
          },
          "input_skill": "MySQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "MySQL",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Angular Dart",
      "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": "angular-dart",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Java",
          "alias_type": "CANONICAL",
          "id": 1,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK",
          "alias_type": "VERSION",
          "id": 2968,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 10",
          "alias_type": "VERSION",
          "id": 2194,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 11",
          "alias_type": "VERSION",
          "id": 4,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 12",
          "alias_type": "VERSION",
          "id": 2196,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 13",
          "alias_type": "VERSION",
          "id": 2197,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 14",
          "alias_type": "VERSION",
          "id": 2198,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 15",
          "alias_type": "VERSION",
          "id": 2199,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 16",
          "alias_type": "VERSION",
          "id": 2200,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 17",
          "alias_type": "VERSION",
          "id": 5,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 18",
          "alias_type": "VERSION",
          "id": 2202,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 19",
          "alias_type": "VERSION",
          "id": 2203,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 20",
          "alias_type": "VERSION",
          "id": 2204,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 21",
          "alias_type": "VERSION",
          "id": 6,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 5",
          "alias_type": "VERSION",
          "id": 2189,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 6",
          "alias_type": "VERSION",
          "id": 2190,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 7",
          "alias_type": "VERSION",
          "id": 2191,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 8",
          "alias_type": "VERSION",
          "id": 3,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 9",
          "alias_type": "VERSION",
          "id": 2193,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.0",
          "alias_type": "VERSION",
          "id": 11,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.1",
          "alias_type": "VERSION",
          "id": 12,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.2",
          "alias_type": "VERSION",
          "id": 13,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.3",
          "alias_type": "VERSION",
          "id": 14,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.4",
          "alias_type": "VERSION",
          "id": 15,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.5",
          "alias_type": "VERSION",
          "id": 16,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.6",
          "alias_type": "VERSION",
          "id": 17,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.7",
          "alias_type": "VERSION",
          "id": 18,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.8",
          "alias_type": "VERSION",
          "id": 19,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 10",
          "alias_type": "VERSION",
          "id": 2211,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 11",
          "alias_type": "VERSION",
          "id": 8,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 12",
          "alias_type": "VERSION",
          "id": 2213,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 13",
          "alias_type": "VERSION",
          "id": 2214,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 14",
          "alias_type": "VERSION",
          "id": 2215,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 15",
          "alias_type": "VERSION",
          "id": 2216,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 16",
          "alias_type": "VERSION",
          "id": 2217,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 17",
          "alias_type": "VERSION",
          "id": 9,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 18",
          "alias_type": "VERSION",
          "id": 2219,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 19",
          "alias_type": "VERSION",
          "id": 2220,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 20",
          "alias_type": "VERSION",
          "id": 2221,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 21",
          "alias_type": "VERSION",
          "id": 10,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 5",
          "alias_type": "VERSION",
          "id": 288,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 6",
          "alias_type": "VERSION",
          "id": 289,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 7",
          "alias_type": "VERSION",
          "id": 290,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 8",
          "alias_type": "VERSION",
          "id": 7,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 9",
          "alias_type": "VERSION",
          "id": 2210,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java11",
          "alias_type": "VERSION",
          "id": 2976,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java17",
          "alias_type": "VERSION",
          "id": 2977,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java21",
          "alias_type": "VERSION",
          "id": 2978,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java8",
          "alias_type": "VERSION",
          "id": 2971,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 11",
          "alias_type": "VERSION",
          "id": 21,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 17",
          "alias_type": "VERSION",
          "id": 22,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 21",
          "alias_type": "VERSION",
          "id": 23,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 8",
          "alias_type": "VERSION",
          "id": 20,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 11",
          "alias_type": "VERSION",
          "id": 1512,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 17",
          "alias_type": "VERSION",
          "id": 1513,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 21",
          "alias_type": "VERSION",
          "id": 1514,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 4",
          "alias_type": "VERSION",
          "id": 1496,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 5",
          "alias_type": "VERSION",
          "id": 1497,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 6",
          "alias_type": "VERSION",
          "id": 1498,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 7",
          "alias_type": "VERSION",
          "id": 1499,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 8",
          "alias_type": "VERSION",
          "id": 1500,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java lts",
          "alias_type": "VERSION",
          "id": 3122,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-11",
          "alias_type": "VERSION",
          "id": 1515,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-17",
          "alias_type": "VERSION",
          "id": 1516,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-21",
          "alias_type": "VERSION",
          "id": 1517,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-4",
          "alias_type": "VERSION",
          "id": 1501,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-5",
          "alias_type": "VERSION",
          "id": 1502,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-6",
          "alias_type": "VERSION",
          "id": 1503,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-7",
          "alias_type": "VERSION",
          "id": 1504,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-8",
          "alias_type": "VERSION",
          "id": 1505,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java11",
          "alias_type": "VERSION",
          "id": 1506,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java17",
          "alias_type": "VERSION",
          "id": 1507,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java21",
          "alias_type": "VERSION",
          "id": 1508,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java4",
          "alias_type": "VERSION",
          "id": 1482,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java5",
          "alias_type": "VERSION",
          "id": 1483,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java6",
          "alias_type": "VERSION",
          "id": 1484,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java7",
          "alias_type": "VERSION",
          "id": 1485,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java8",
          "alias_type": "VERSION",
          "id": 1486,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 11",
          "alias_type": "VERSION",
          "id": 1509,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 17",
          "alias_type": "VERSION",
          "id": 1510,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 21",
          "alias_type": "VERSION",
          "id": 1511,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 4",
          "alias_type": "VERSION",
          "id": 1487,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 5",
          "alias_type": "VERSION",
          "id": 1488,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 6",
          "alias_type": "VERSION",
          "id": 1489,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 7",
          "alias_type": "VERSION",
          "id": 1490,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 8",
          "alias_type": "VERSION",
          "id": 1491,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk11",
          "alias_type": "VERSION",
          "id": 1492,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk17",
          "alias_type": "VERSION",
          "id": 1493,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk21",
          "alias_type": "VERSION",
          "id": 1494,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk4",
          "alias_type": "VERSION",
          "id": 1477,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk5",
          "alias_type": "VERSION",
          "id": 1478,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk6",
          "alias_type": "VERSION",
          "id": 1479,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk7",
          "alias_type": "VERSION",
          "id": 1480,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk8",
          "alias_type": "VERSION",
          "id": 1481,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jvm21",
          "alias_type": "VERSION",
          "id": 1495,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Java",
        "id": 1,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "java",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Java Language and JVM",
            "id": 279,
            "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
            "slug": "java-language-and-jvm",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kotlin and Java",
            "id": 161,
            "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
            "slug": "kotlin-and-java",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Pega Programming Languages \u0026 DSLs",
            "id": 267,
            "rationale": "Programming languages and domain-specific languages used in Pega development.",
            "slug": "pega-programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \u0026 DSLs",
            "id": 475,
            "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
            "slug": "programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 21,
            "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Java",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "SQL",
          "alias_type": "CANONICAL",
          "id": 271,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "SQL",
        "id": 101,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "sql",
        "sub_category_id": 97,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "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": "SQL",
          "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 \u0026 DSLs",
            "id": 475,
            "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
            "slug": "programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "SQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 21,
            "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "SQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "SQL",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "Angular Dart"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "Frontend Developer",
    "id": 7,
    "rationale": "LLM2 picked frontend-engineer (confidence 0.90)",
    "role_archetype": null,
    "slug": "frontend-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "JavaScript",
      "tag": "in_db"
    },
    {
      "skill": "HTML",
      "tag": "in_db"
    },
    {
      "skill": "CSS",
      "tag": "in_db"
    },
    {
      "skill": "TypeScript",
      "tag": "in_db"
    },
    {
      "skill": "Unit Testing",
      "tag": "in_db"
    },
    {
      "skill": "End-to-End Testing",
      "tag": "in_db"
    },
    {
      "skill": "GCP",
      "tag": "in_db"
    },
    {
      "skill": "Python",
      "tag": "in_db"
    },
    {
      "skill": "MySQL",
      "tag": "in_db"
    },
    {
      "skill": "Angular Dart",
      "tag": "new"
    },
    {
      "skill": "Java",
      "tag": "in_db"
    },
    {
      "skill": "SQL",
      "tag": "in_db"
    }
  ],
  "llm_cost_api1_usd": null,
  "llm_cost_api2_usd": null,
  "llm_cost_api3_usd": null,
  "llm_cost_total_usd": null,
  "persistence": {
    "items": [
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "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"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 DSLs",
          "id": 475,
          "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
          "slug": "programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 475,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 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": "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": "HTML",
        "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": 1657,
        "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": "HTML",
        "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": 1657,
        "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": "HTML",
        "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": 1657,
        "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": "HTML",
        "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": 1657,
        "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": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "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": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Unit Testing",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 517,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Testing and Quality Assurance",
          "id": 12,
          "rationale": "Backend-specific test strategies used to validate service behavior and integration points. Covers automated test layers, contract checks, fixtures, and regression prevention.",
          "slug": "testing-and-quality-assurance",
          "source": "db"
        },
        "dimension_id": 12,
        "input_skill": "End-to-End Testing",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "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": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "GCP",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          },
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 186,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms for AI Deployment",
          "id": 211,
          "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
          "slug": "cloud-platforms-for-ai-deployment",
          "source": "db"
        },
        "dimension_id": 211,
        "input_skill": "GCP",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 186,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Provider Platforms",
          "id": 131,
          "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
          "slug": "cloud-provider-platforms",
          "source": "db"
        },
        "dimension_id": 131,
        "input_skill": "GCP",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 186,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Posture Tools",
          "id": 64,
          "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
          "slug": "cloud-security-posture-tools",
          "source": "db"
        },
        "dimension_id": 64,
        "input_skill": "GCP",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          },
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 186,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Scripting \u0026 DSL Languages",
          "id": 248,
          "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
          "slug": "cloud-security-scripting-dsl-languages",
          "source": "db"
        },
        "dimension_id": 248,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 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": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 DSLs",
          "id": 475,
          "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
          "slug": "programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 475,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages and Scripting",
          "id": 59,
          "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
          "slug": "programming-languages-and-scripting",
          "source": "db"
        },
        "dimension_id": 59,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 39,
          "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 39,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Python Programming",
          "id": 290,
          "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
          "slug": "python-programming",
          "source": "db"
        },
        "dimension_id": 290,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Data Modeling",
          "id": 216,
          "rationale": "Modeling and tuning relational persistence for backend features. PHP backend developers need this to shape schemas, indexes, transactions, and query-aware data structures that support application behavior.",
          "slug": "relational-data-modeling",
          "source": "db"
        },
        "dimension_id": 216,
        "input_skill": "MySQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Design",
          "id": 4,
          "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
          "slug": "relational-database-design",
          "source": "db"
        },
        "dimension_id": 4,
        "input_skill": "MySQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Usage",
          "id": 371,
          "rationale": "Working effectively with operational relational databases from Go backend services. This includes schema-aware querying, indexing awareness, transactions, and understanding how service code interacts with PostgreSQL or similar systems.",
          "slug": "relational-database-usage",
          "source": "db"
        },
        "dimension_id": 371,
        "input_skill": "MySQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Java Language and JVM",
          "id": 279,
          "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
          "slug": "java-language-and-jvm",
          "source": "db"
        },
        "dimension_id": 279,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Kotlin and Java",
          "id": 161,
          "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
          "slug": "kotlin-and-java",
          "source": "db"
        },
        "dimension_id": 161,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Languages",
          "id": 274,
          "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
          "slug": "native-mobile-languages",
          "source": "db"
        },
        "dimension_id": 274,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Pega Programming Languages \u0026 DSLs",
          "id": 267,
          "rationale": "Programming languages and domain-specific languages used in Pega development.",
          "slug": "pega-programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 267,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 DSLs",
          "id": 475,
          "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
          "slug": "programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 475,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "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": "SQL",
        "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": 101,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 DSLs",
          "id": 475,
          "rationale": "Oversee and guide the selection and effective use of programming and domain\u2010specific languages in software projects.",
          "slug": "programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 475,
        "input_skill": "SQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 101,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 7,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "SQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 101,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 1
  },
  "planner_output": null,
  "run_id": "58445421-dd03-4bd0-ad5e-f9238778d282"
}

LLM Calls

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

Loading…